API文档 => java.io => File


File类的应用

File类的概述

文件可认为是相关记录或放在一起的数据的集合
在Java中，使用java.io.file类对文件进行操作

File类的常用方法

getName()：文件名
getParent()：文件所在目录的路径
getPath()：文件的相对路径
getAbsolutePath()：文件的绝对路径

案例1：

  1. package com.file;
  3. import java.io.File;
  4. import java.io.IOException;
  6. public class FileDemo {
  7.     public static void main(String[] args){
  8.         // 创建File对象
  9.         File file1 = new File("/Users/chenyisong/study/java-file/score.txt");
  10.         File file2 = new File("/Users/chenyisong","study/java-file/score.txt");
  11.         File file3 = new File("/Users/chenyisong");
  12.         File file4 = new File(file3,"study/java-file/score.txt");
  14.         // 判断是文件还是目录
  15.         // score.txt是已经存在的，这时候可以判断出来是文件还是目录
  16.         System.out.println(file1.isDirectory());    // false
  17.         System.out.println(file2.isDirectory());    // false
  18.         System.out.println(file4.isDirectory());    // false
  20.         System.out.println(file1.isFile());         // true
  21.         System.out.println(file2.isFile());         // true
  22.         System.out.println(file4.isFile());         // true
  24.         // 创建单级目录
  25.         File file5 = new File("/Users/chenyisong/study/java-file","hashSet");
  26.         if(!file5.exists()){
  27.             file5.mkdir();
  28.         }
  30.         // 创建多级目录
  31.         File file6 = new File("/Users/chenyisong/study/java-file/hashSet/set");
  32.         if(!file6.exists()){
  33.             file6.mkdirs();
  34.         }
  36.         // 创建文件
  37.         File file7 = new File("/Users/chenyisong/study/java-file/name.txt");
  38.         // name.txt是还不存在的，那么无法判断出是文件还是目录
  39.         System.out.println(file7.isDirectory());    // false
  40.         System.out.println(file7.isFile());         // false
  42.         if(!file7.exists()){
  43.             try {
  44.                 file7.createNewFile();
  45.             } catch (IOException e) {
  46.                 e.printStackTrace();
  47.             }
  48.         }
  50.         System.out.println(file7.getName());        // name.txt
  51.         System.out.println(file7.getParent());      // /Users/chenyisong/study/java-file
  52.         System.out.println(file7.getPath());        // /Users/chenyisong/study/java-file/name.txt
  53.     }
  54. }

案例2：

  1. package com.file;
  3. import java.io.File;
  4. import java.io.IOException;
  6. public class FileDemo {
  7.     public static void main(String[] args){
  8.         File file = new File("thread.txt");
  10.         try {
  11.             file.createNewFile();
  13.             System.out.println(file.isAbsolute());      // false
  14.             System.out.println(file.getPath());         // thread.txt
  15.             System.out.println(file.getAbsolutePath()); // /Users/chenyisong/study/java-project/thread.txt
  16.             System.out.println(file.getName());         // thread.txt
  17.         } catch (IOException e) {
  18.             e.printStackTrace();
  19.         }
  20.     }
  21. }

字节流

字节流包括字节输入流（InputStream）和字节输出流（OutputStream）

image.png
image.png

FileInputStream

  • 从文件系统中的某个文件中获得输入字节
  • 用于读取诸如图像数据之类的原始字节流

由于以下编码方式原因，文件输入输出流比较适合复制图像等二进制文件，而不是适合处理字符
#如果要处理字符，建议使用字符流

API文档 => java.io => FileInputStream

image.png

案例1：

  1. package com.file;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.IOException;
  7. public class FileInputDemo {
  8.     public static void main(String[] args){
  9.         // 创建一个FileInputStream对象
  11.         try {
  12.             FileInputStream fileInputStream = new FileInputStream("thread.txt");
  13.             int n = 0;
  14.             while ((n=fileInputStream.read())!=-1){
  15.                 System.out.print((char)n);
  16.             }
  17.             fileInputStream.close();    // 记得读取完之后关闭文件输入流
  18.         } catch (FileNotFoundException e) {
  19.             e.printStackTrace();
  20.         } catch (IOException e){
  21.             e.printStackTrace();
  22.         }
  23.     }
  24. }

运行结果：hello java!

案例2：

  1. package com.file;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.IOException;
  7. public class FileInputDemo {
  8.     public static void main(String[] args) {
  9.         // 创建一个FileInputStream对象
  11.         try {
  12.             FileInputStream fileInputStream = new FileInputStream("thread.txt");
  13.             byte[] bytes = new byte[100];
  15.             // 一次性从输入流中读取100byte数据，并放到数组bytes中
  16.             fileInputStream.read(bytes);
  18.             System.out.println(new String(bytes));
  19.             fileInputStream.close();
  20.         } catch (FileNotFoundException e) {
  21.             e.printStackTrace();
  22.         } catch (IOException e) {
  23.             e.printStackTrace();
  24.         }
  25.     }
  26. }

运行结果：hello java!*

案例3：

  1. package com.file;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.IOException;
  7. public class FileInputDemo {
  8.     public static void main(String[] args) {
  9.         // 创建一个FileInputStream对象
  11.         try {
  12.             FileInputStream fileInputStream = new FileInputStream("thread.txt");
  13.             byte[] bytes = new byte[100];
  15.             // 一次性从输入流中读取10byte数据，并存放到bytes数组中（从数组下标6开始存储）
  16.             fileInputStream.read(bytes,5,10);
  18.             System.out.println(new String(bytes));
  19.             fileInputStream.close();
  20.         } catch (FileNotFoundException e) {
  21.             e.printStackTrace();
  22.         } catch (IOException e) {
  23.             e.printStackTrace();
  24.         }
  25.     }
  26. }

运行结果：
*hello java*

FileOutputStream

API文档 => java.io => FileOutputStream

image.png

案例1：

  1. package com.file;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  7. public class FileOutputDemo {
  8.     public static void main(String[] args){
  9.         try {
  10.             FileOutputStream fileOutputStream = new FileOutputStream("thread.txt");
  11.             fileOutputStream.write(50);
  12.             fileOutputStream.write('a');
  13.             fileOutputStream.close();
  14.         } catch (FileNotFoundException e) {
  15.             e.printStackTrace();
  16.         } catch (IOException e){
  17.             e.printStackTrace();
  18.         }
  19.     }
  20. }

运行结果：2a
#根据ASCII码，其中2是50所代表的字符

案例2：

  1. package com.file;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  8. public class FileOutputDemo {
  9.     public static void main(String[] args) {
  10.         // 文件拷贝
  11.         try {
  12.             FileInputStream fileInputStream = new FileInputStream("mac.png");
  13.             FileOutputStream fileOutputStream = new FileOutputStream("macCopy.png");
  15.             int n = 0;
  16.             byte[] bytes = new byte[1024];
  17.             while ((n = fileInputStream.read(bytes)) != -1) {
  18.                 fileOutputStream.write(bytes, 0, n);
  19.                 // n 代表读取到的实际字节数
  20.                 // 注意这里不要写成 fileOutputStream.write(bytes) 
  21.                 // 试想一下，最后一次从输入流中读取1024个字节数据的时候，可能这1024个字节并不都是有效数据，也许只有1000字节是有效的
  22.                 // 这时候还是按1024字节填充到目标文件的话，会造成浪费
  23.             }
  24.             fileInputStream.close();
  25.             fileOutputStream.close();
  26.         } catch (FileNotFoundException e) {
  27.             e.printStackTrace();
  28.         } catch (IOException e) {
  29.             e.printStackTrace();
  30.         }
  31.     }
  32. }

BufferedInputStream

BufferedOutputStream

  • 使用缓冲输入输出流可以提高读写速度
  • BufferedOutputStream的方法flush()是用来清空缓冲区的

当缓冲区被填满时就会自动执行写操作，但是当缓冲区不满时，就不会执行写操作。所以，当缓冲区未 被填满但要执行写操作时就要强制清空缓冲区

  1. package com.file;
  3. import java.io.*;
  5. public class FileOutputDemo {
  6.     public static void main(String[] args) {
  7.         try {
  8.             FileOutputStream fos = new FileOutputStream("thread.txt");
  9.             BufferedOutputStream bos = new BufferedOutputStream(fos);
  11.             FileInputStream fis = new FileInputStream("thread.txt");
  12.             BufferedInputStream bis = new BufferedInputStream(fis);
  14.             bos.write(50);
  15.             bos.write('c');
  16.             bos.flush();
  18.             System.out.print(bis.read());
  19.             System.out.print((char)bis.read());
  21.             fos.close();
  22.             bos.close();
  23.             fis.close();
  24.             bis.close();
  25.         } catch (FileNotFoundException e) {
  26.             e.printStackTrace();
  27.         } catch (IOException e) {
  28.             e.printStackTrace();
  29.         }
  30.     }
  31. }

字符流

字符流包括字符输入流Reader和字符输出流Writer

image.png
image.png

InputStreamReader

OutputStreamReader

字节字符转换流

案例1：一个字符一个字符读取

  1. package com.file;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.IOException;
  6. import java.io.InputStreamReader;
  8. public class ReadDemo {
  9.     public static void main(String[] args) {
  10.         try {
  11.             FileInputStream fis = new FileInputStream("thread.txt");
  12.             InputStreamReader isr = new InputStreamReader(fis);
  14.             int n = 0;
  16.             while ((n = isr.read()) != -1) {
  17.                 System.out.print((char) n);
  18.             }
  19.             fis.close();
  20.             isr.close();
  21.         } catch (FileNotFoundException e) {
  22.             e.printStackTrace();
  23.         } catch (IOException e) {
  24.             e.printStackTrace();
  25.         }
  26.     }
  27. }

运行结果：
你好，Java
你好，Java
你好，Java

你好，Java
你好，Java
你好，Java

案例2：批量读取字符

  1. package com.file;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.IOException;
  6. import java.io.InputStreamReader;
  8. public class ReadDemo {
  9.     public static void main(String[] args) {
  10.         try {
  11.             FileInputStream fis = new FileInputStream("thread.txt");
  12.             InputStreamReader isr = new InputStreamReader(fis);
  14.             int n = 0;
  15.             char[] cbuf = new char[10];
  17.             while ((n = isr.read(cbuf)) != -1) {
  18.                 String s = new String(cbuf, 0, n);
  19.                 System.out.print(s);
  20.             }
  21.             fis.close();
  22.             isr.close();
  23.         } catch (FileNotFoundException e) {
  24.             e.printStackTrace();
  25.         } catch (IOException e) {
  26.             e.printStackTrace();
  27.         }
  28.     }
  29. }

运行结果：
你好，Java
你好，Java
你好，Java

你好，Java
你好，Java
你好，Java

案例3：写入字符串

  1. package com.file;
  3. import java.io.*;
  5. public class ReadDemo {
  6.     public static void main(String[] args) {
  7.         try {
  8.             FileInputStream fis = new FileInputStream("thread.txt");
  9.             InputStreamReader isr = new InputStreamReader(fis);
  10.             FileOutputStream fos = new FileOutputStream("threadCopy.txt");
  11.             OutputStreamWriter osw = new OutputStreamWriter(fos);
  13.             int n = 0;
  14.             char[] cbuf = new char[10];
  16.             while ((n = isr.read(cbuf)) != -1) {
  17.                 osw.write(cbuf,0,n);
  18.             }
  19.             osw.flush();
  21.             fis.close();
  22.             fos.close();
  23.             isr.close();
  24.             osw.close();
  25.         } catch (FileNotFoundException e) {
  26.             e.printStackTrace();
  27.         } catch (IOException e) {
  28.             e.printStackTrace();
  29.         }
  30.     }
  31. }

运行结果：复制thread.txt的内容到threadCopy.txt

对象的序列化与反序列化

  • 创建一个类，实现Serializable接口
  • 创建对象
  • 将对象写入文件
  • 从文件读取对象信息

序列化：把Java对象转换为字节序列的过程
反序列化：把字节序列恢复为Java对象的过程

ObjectInputStream

ObjectOutputStream

对象输入输出流

  1. package com.serial;
  3. import java.io.*;
  5. public class GoodsTest {
  6.     public static void main(String[] args) {
  7.         // 定义Goods类的对象
  8.         Goods goods1 = new Goods("gd001", "电脑", 3000);
  10.         try {
  11.             FileOutputStream fos = new FileOutputStream("good.txt");
  12.             ObjectOutputStream oos = new ObjectOutputStream(fos);
  14.             FileInputStream fis = new FileInputStream("good.txt");
  15.             ObjectInputStream ois = new ObjectInputStream(fis);
  17.             // 将goods信息写入文件
  18.             oos.writeObject(goods1);
  19.             oos.flush();
  21.             // 读取对象信息
  22.             try {
  23.                 Goods goods = (Goods) ois.readObject();
  24.                 System.out.println(goods);
  25.             } catch (ClassNotFoundException e) {
  26.                 e.printStackTrace();
  27.             }
  29.             fos.close();
  30.             oos.close();
  31.             fis.close();
  32.             ois.close();
  33.         } catch (FileNotFoundException e) {
  34.             e.printStackTrace();
  35.         } catch (IOException e) {
  36.             e.printStackTrace();
  37.         }
  38.     }
  39. }