0 准备
1 文件
- 1.1 文件常用操作
- - 1.1.1 创建文件
  - 1.1.2 获取文件信息
  - 1.1.3 文件删除
  - 1.1.4 创建目录
2 IO流
- 2.1 原理及分类
- 2.2 常用IO流
- - 2.2.1 文件字节输入流 FileInputStream
  - 2.2.2 文件字节输出流 FileOutputStream
  - 2.2.3 文件字符输入流 FileReader
  - 2.2.4 文件字符输出流 FileWriter
  - 2.2.5 缓冲字节输入流 BufferedInputStream
  - 2.2.6 缓冲字节输出流 BufferedOutputStream
  - 2.2.7 缓冲字符输入流 BufferedReader
  - 2.2.8 缓冲字符输出流 BufferedWriter
  - 2.2.9 对象输字节出流 ObjectOutputStream
  - 2.2.10 对象字节输入流 ObjectInputStream
  - 2.2.11 标准输入输出流 System.in / System.out
  - 2.2.12 转换字符输入流 InputStreamReader (防止中文乱码)
  - 2.2.13 转换字符输出流 OutputStreamWriter (防止中文乱码)
  - 2.2.14 字节打印输出流 PrintStream
  - 2.2.14 字符打印输出流 PrintWriter
  - 2.2.15 配置文件操作 properties

0 准备

需要的依赖

    <dependencies><dependency><groupId>commons-io</groupId><artifactId>commons-io</artifactId><version>2.11.0</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope></dependency></dependencies>

1 文件

文件在程序中以流的形式来操作的，输入流与输出流中的输入与输出针对的是内存。

File继承关系

1.1 文件常用操作

1.1.1 创建文件

    /*** 创建文件 方法1* <p>* new File(String pathname)*/@Testpublic void createFile_test01() {// File对象在内存中File file = new File("D:\\news1.txt");try {// 内存中的File对象写入磁盘file.createNewFile();System.out.println("文件创建成功");} catch (IOException e) {e.printStackTrace();}}/*** 创建文件 方法2* <p>* new File(File parent,String child)*/@Testpublic void createFile_test02() {File parent = new File("D:\\");String child = "news2.txt";File file = new File(parent, child);try {file.createNewFile();System.out.println("创建成功");} catch (IOException e) {e.printStackTrace();}}/*** 创建文件 方法3* <p>* new File(String parent, String child)*/@Testpublic void createFile_test03() {File file = new File("D:\\", "news3.txt");try {file.createNewFile();System.out.println("创建成功");} catch (IOException e) {e.printStackTrace();}}

1.1.2 获取文件信息

    /*** 获取文件信息*/@Testpublic void getFileInfo_test01() {// 创建文件对象File file = new File("D:\\news1.txt");// 获取文件名System.out.println(file.getName());// 获取绝对路径System.out.println(file.getAbsolutePath());// 获取文件父级目录System.out.println(file.getParent());// 获取文件字节大小（在utf-8下，一个英文字符是1个字节，一个汉字是3个字节）System.out.println(file.length());// 判断文件是否存在System.out.println(file.exists());// 是不是一个文件System.out.println(file.isFile());// 是不是一个目录System.out.println(file.isDirectory());}

1.1.3 文件删除

delete删除空目录或文件（delete删除一个目录时，需要确保该目录下面没有文件或者子目录，否则需要先删除文件和字目录）

    /*** 判断 “d:\\news1.txt” 是否存在，如果存在就删除*/@Testpublic void deleteFile_test01() {String filePath = "d:\\news1.txt";File file = new File(filePath);if (file.exists()) {if (file.delete()) {System.out.println(filePath + "删除成功");} else {System.out.println(filePath + "删除失败");}} else {System.out.println("该文件不存在...");}}/*** 判断 “D:\\demo02” 是否存在，存在就删除，否则提示不存在* <p>* 这里需要体会到，在java编程中，目录也被当做文件*/@Testpublic void deleteFile_test02() {String filePath = "D:\\demo02";File file = new File(filePath);if (file.exists()) {if (file.delete()) {System.out.println(filePath + "删除成功");} else {System.out.println(filePath + "删除失败");}} else {System.out.println("该目录不存在...");}}

1.1.4 创建目录

mkdir 创建一级目录
mkdirs 创建多级目录

    /*** 判断 “D:\\demo\\a\\b\\c” 目录是否存在，如果存在就提示已经存在，否则就创建*/@Testpublic void mkdirs_test01() {String directoryPath = "D:\\demo\\a\\b\\c";File file = new File(directoryPath);if (file.exists()) {System.out.println(directoryPath + "存在..");} else {// 创建一级目录使用mkdir() ，创建多级目录使用mkdirs()if (file.mkdirs()) {System.out.println(directoryPath + "创建成功..");} else {System.out.println(directoryPath + "创建失败...");}}}

2 IO流

2.1 原理及分类

io流简介

i/o是input/output的缩写， i/o技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。
java程序中，对于数据的输入/输出操作以“流(stream)” 的方式进行。
java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。

io流原理

输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中。

流的分类

(1) 输入输出流
按照流的流向分为输入流和输出流。是以内存的角度来划分。
输入流：只能读取数据，不能写入。由InputStream 和 Reader作为基类;
输出流：只能写入数据，不能读取。由OutputStream 和 Writer 作为基类;

(2) 字节流和字符流
字节流：操作数据单元为 8 位字节，由 InputStream 和 OutputStream作为基类;
字符流：操作数据单元为16位字符，由 Reader 和 Writer 作为基类;

(3) 节点流和处理流
按角色分为节点流和处理流。
节点流：从一个特定的IO设备（磁盘，或网络）读写数据的流，称为。
包装流：也叫处理流，对节点流的封装，提供更丰富的功能与更好的性能。
使用装饰器设计模式。

四个基本抽象类

均为抽象类，都需要调用他们的实现子类创建。

基于以上四个抽象类，根据各种业务场景的需要衍生出如下IO流操作相关类

使用注意事项：

字符输出流 xxWriter 必须调用 flush()或close() 才能实际写出；
字符流会有编码导致的中文乱码问题，所以操作字符流要指定字符编码格式；
包装流提供更丰富的功能与更好的性能，一包会在最外层套用包装流；

2.2 常用IO流

2.2.1 文件字节输入流 FileInputStream

read() 方法是一个一个字节去读取，中文一个占三个字节，故会出现乱码，并且效率极低

    /*** 方法：* public int read() throws IOException* 从该输入流读取一个字节的数据。 如果没有输入可用，此方法将阻止。* <p>* 结果：* 数据的下一个字节，如果达到文件的末尾，-1。* <p>* 注意:* 一个中文大于一个字节，中文一定会很乱码。*/@Testpublic void test_read() {String filePath = "src\\main\\resources\\fileInputStream";int readData = 0;InputStream inputStream = null;try {inputStream = new FileInputStream(filePath);while ((readData = inputStream.read()) != -1) {System.out.print((char) readData);    // 转换成char显示}} catch (Exception e) {e.printStackTrace();} finally {// 一定要关闭文件流，释放资源IOUtils.closeQuietly(inputStream);}}

一般使用的是 read(byte[] byte) 。一次性读取一个指定长度的字节

    /*** 方法：* public int read(byte[] b) throws IOException* 从该输入流读取最多b.length字节的数据到字节数组。 此方法将阻塞，直到某些输入可用。* <p>* 参数：* b - 读取数据的缓冲区。取值合理不会出现中文乱码* <p>* 结果:* 读入缓冲区的总字节数，如果没有更多的数据，因为文件的结尾已经到达， -1 。*/@Testpublic void test_read_bytes() {String filePath = "src\\main\\resources\\fileInputStream";int readLen = 0;// bytes 取值为中文字符的整数倍则不会中文乱码byte[] bytes = new byte[3];InputStream inputStream = null;try {inputStream = new FileInputStream(filePath);while ((readLen = inputStream.read(bytes)) != -1) {// 注意最后一次读取时，bytes不满的情况下，后边不满的几位会缓存上次循环的数据System.out.print(new String(bytes, 0, readLen));}} catch (Exception e) {e.printStackTrace();} finally {// 一定要关闭文件流，释放资源IOUtils.closeQuietly(inputStream);}}

2.2.2 文件字节输出流 FileOutputStream

    /*** 使用FileOutputStream 在a.txt文件,中写入"hello, world"* 对于FileOutputStream，如果文件不存在，会创建文件(注意:前提是目录已经存在)*/@Testpublic void test_write() {// 创建 FileOutputStream对象String filePath = "src\\main\\resources\\a.txt";FileOutputStream fileOutputStream = null;try {// 1. new FileOutputStream(filePath) 创建方式，当写入内容时，会覆盖原来的内容。// 2. new FileOutputStream(filePath, true) 创建方式，当写入内容是，是追加到文件后面。fileOutputStream = new FileOutputStream(filePath, true);// 写入一个字节fileOutputStream.write('H');// 写入字符串（字符串-> 字节数组）String str = "hello,world!";fileOutputStream.write(str.getBytes());// 截取字符串一部分进行写入 [0,5)fileOutputStream.write(str.getBytes(), 0, 5);} catch (IOException e) {e.printStackTrace();} finally {IOUtils.closeQuietly(fileOutputStream);}}

    /*** 文件拷贝*/@Testpublic void fileCopy() {String inputFilePath = "src\\main\\resources\\王者荣耀.jpg";String outFilePath = "src\\main\\resources\\王者荣耀_copy.jpg";FileOutputStream fileOutputStream = null;FileInputStream fileInputStream = null;byte[] buf = new byte[1024];int readLength = 0;try {fileInputStream = new FileInputStream(inputFilePath);fileOutputStream = new FileOutputStream(outFilePath, true);while ((readLength = fileInputStream.read(buf)) != -1) {// 注意：一定要使用这个方法,防止buf缓存倒数第二次结果，可能造成文件损坏fileOutputStream.write(buf, 0, readLength);}System.out.println("文件拷贝成功");} catch (Exception e) {e.printStackTrace();} finally {// 注意先关闭输入流，在关闭输出流IOUtils.closeQuietly(fileInputStream, fileOutputStream);}}

2.2.3 文件字符输入流 FileReader

可以处理中文字符

    /*** 单个字符读取文件(效率很低)*/@Testpublic void readFile01() {String filePath = "src\\main\\resources\\a.txt";FileReader fileReader = null;int data = 0;try {fileReader = new FileReader(filePath);// 循环读取 使用read, 单个字符读取while ((data = fileReader.read()) != -1) {System.out.print((char) data);}} catch (IOException e) {e.printStackTrace();} finally {// 一定要关闭文件流，释放资源IOUtils.closeQuietly(fileReader);}}/*** 字符数组读取文件*/@Testpublic void readFile02() {String filePath = "src\\main\\resources\\a.txt";FileReader fileReader = null;int readLen = 0;char[] buf = new char[8];try {fileReader = new FileReader(filePath);// 循环读取使用read(buf), 返回的数据缓存在字符数组buf// 如果返回-1, 说明到文件结束while ((readLen = fileReader.read(buf)) != -1) {System.out.print(new String(buf, 0, readLen));}} catch (IOException e) {e.printStackTrace();} finally {// 一定要关闭文件流，释放资源IOUtils.closeQuietly(fileReader);}}

2.2.4 文件字符输出流 FileWriter

使用FileWriter时 flush()或close必须执行期其中一个，不然无法写入文件

    @Testpublic void write_Test() {String filePath = "src\\main\\resources\\b.txt";FileWriter fileWriter = null;try {// 覆盖方式// fileWriter = new FileWriter(filePath);// 追加方式fileWriter = new FileWriter(filePath, true);// 1. write(int) 写入单个字符fileWriter.write('H');// 2. write(char[]): 写入字符数组char[] chars = {'a', 'b', 'c'};fileWriter.write(chars);// 默认是覆盖// 3. write(char[],off,len): 写入字符数组的截取部分fileWriter.write("李淳罡--陆地神仙境".toCharArray(), 0, 3);// 4. write(String) :写入整个字符串fileWriter.write("你好啊北京");// 5. write(string,off,len):写入字符串的截取部分fileWriter.write("李白--诗仙", 0, 2);// 在数据量比较大的时候采用循环才做// 注意：flush()或close() 必须执行期其中一个，否则不会输出到文件// 因为实际写出到文件的操作在这两个方法中被调用fileWriter.flush();System.out.println("文件输出成功");} catch (Exception e) {e.printStackTrace();} finally {// 一定要关闭文件流，释放资源IOUtils.closeQuietly(fileWriter);}}

2.2.5 缓冲字节输入流 BufferedInputStream

    @Testpublic void test_readLine() {String filePath = "src\\main\\resources\\a.txt";int readLen = 0;byte[] buf = new byte[1024]; // 取值为中文字符的整数倍则不会中文乱码BufferedInputStream bufferedInputStream = null;try {bufferedInputStream = new BufferedInputStream(new FileInputStream(filePath));while ((readLen = bufferedInputStream.read(buf)) != -1) {System.out.println(new String(buf, 0, readLen));}} catch (Exception e) {e.printStackTrace();} finally {// 关闭装饰流，实际会关闭其内部持有的节点流IOUtils.closeQuietly(bufferedInputStream);}}

2.2.6 缓冲字节输出流 BufferedOutputStream

    @Testpublic void test_copy() {String inputFilePath = "src\\main\\resources\\王者荣耀.jpg";String outputFilePath = "src\\main\\resources\\王者荣耀_copy1.jpg";byte[] buf = new byte[1024];int readLen;BufferedInputStream bufferedInputStream = null;BufferedOutputStream bufferedOutputStream = null;try {bufferedInputStream = new BufferedInputStream(new FileInputStream(inputFilePath));bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(outputFilePath));while ((readLen = bufferedInputStream.read(buf)) != -1) {// 注意：一定要使用这个方法,防止buf缓存倒数第二次结果，可能造成文件损坏bufferedOutputStream.write(buf, 0, readLen);}} catch (Exception e) {e.printStackTrace();} finally {// 关闭装饰流，实际会关闭其内部持有的节点流IOUtils.closeQuietly(bufferedInputStream, bufferedOutputStream);}}

2.2.7 缓冲字符输入流 BufferedReader

BufferedReader属于字符流，是按照字符读取数据的，所以最好处理文本文件，像图片，声音这种字节组织的二进制文件的话，用字符流读取可能会造成文件损失，所以最好使用字节流。

    @Testpublic void test_readLine() {String filePath = "src\\main\\resources\\a.txt";BufferedReader bufferedReader = null;try {// 创建 BufferedReaderbufferedReader = new BufferedReader(new FileReader(filePath));// 按行读取，效率高String line;while ((line = bufferedReader.readLine()) != null) {System.out.println(line);}} catch (Exception e) {e.printStackTrace();} finally {// 关闭装饰流，实际会关闭其内部持有的节点流IOUtils.closeQuietly(bufferedReader);}}

2.2.8 缓冲字符输出流 BufferedWriter

BufferedWriter属于字符流，是按照字符读取数据的，所以最好处理文本文件，像图片，声音这种字节组织的二进制文件的话，用字符流读取可能会造成文件损失，所以最好使用字节流。

    @Testpublic void test_write() {String filePath = "src\\main\\resources\\d.txt";BufferedWriter bufferedWriter = null;try {// 覆盖的方式// bufferedWriter = new BufferedWriter(new FileWriter(filePath));// 追加的方式bufferedWriter = new BufferedWriter(new FileWriter(filePath, true));for (int i = 0; i < 3; i++) {bufferedWriter.write("你好啊,boy!");bufferedWriter.newLine();bufferedWriter.write("你好啊,小胖子!");bufferedWriter.write("你好啊,girls!");// 注意：flush()或close() 必须执行期其中一个，否则不会输出到文件// 因为实际写出到文件的操作在这两个方法中被调用bufferedWriter.flush();}System.out.println("写出完成");} catch (Exception e) {e.printStackTrace();} finally {// 关闭装饰流，实际会关闭其内部持有的节点流IOUtils.closeQuietly(bufferedWriter);}}

    /*** 文件拷贝* <p>* 不要去操作 二进制文件[声音，视频，doc, pdf 等], 可能造成文件损坏!!*/@Testpublic void test_copy() {String inputFilePath = "src\\main\\resources\\a.txt";String outputFilePath = "src\\main\\resources\\a_copy.txt";BufferedWriter bufferedWriter = null;BufferedReader bufferedReader = null;try {bufferedReader = new BufferedReader(new FileReader(inputFilePath));bufferedWriter = new BufferedWriter(new FileWriter(outputFilePath));String readLine;while ((readLine = bufferedReader.readLine()) != null) {bufferedWriter.write(readLine);// readLine读取一行的时候没有读取换行符bufferedWriter.newLine();}System.out.println("完成拷贝...");} catch (IOException e) {e.printStackTrace();} finally {// 关闭装饰流，实际会关闭其内部持有的节点流IOUtils.closeQuietly(bufferedReader, bufferedWriter);}}

2.2.9 对象输字节出流 ObjectOutputStream

将 java对象序列化后输出到文件（要求 java对象支持序列化）

public class Dog implements Serializable {private String name;private int age;public Dog(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Dog{" +"name='" + name + '\'' +", age=" + age +'}';}
}

    /*** 序列化输出到文件*/@Testpublic void test() {// 序列化之后，保存的文件格式，不是存文本，而是按照他的格式来保存String filePath = "src\\main\\resources\\dog.dat";ObjectOutputStream objectOutputStream = null;try {objectOutputStream = new ObjectOutputStream(new FileOutputStream(filePath));objectOutputStream.writeInt(100);         // int -> Integer (实现了 Serializable)objectOutputStream.writeBoolean(true);    // boolean -> Boolean (实现了 Serializable)objectOutputStream.writeChar('a');        // char -> Character (实现了 Serializable)objectOutputStream.writeDouble(9.5);      // double -> Double (实现了 Serializable)objectOutputStream.writeUTF("莫寒寒来咯!"); // String (实现了 Serializable)objectOutputStream.writeObject(new Dog("旺财", 10)); // Dog (实现了 Serializable)System.out.println("序列化输出成功...");} catch (Exception e) {e.printStackTrace();} finally {// 关闭装饰流，实际会关闭其内部持有的节点流IOUtils.closeQuietly(objectOutputStream);}}

2.2.10 对象字节输入流 ObjectInputStream

将文件中的数据读取并反序列化为 java对象（要求 java对象支持序列化）

   /*** 序列化输出到文件*/@Testpublic void test() {String filePath = "src\\main\\resources\\dog.dat";ObjectInputStream objectInputStream = null;try {objectInputStream = new ObjectInputStream(new FileInputStream(filePath));// 注意：读取反序列化的顺序需要和保存数据序列化的顺序一致，否则会出异常System.out.println(objectInputStream.readInt());System.out.println(objectInputStream.readBoolean());System.out.println(objectInputStream.readChar());System.out.println(objectInputStream.readDouble());System.out.println(objectInputStream.readUTF());Object dog = objectInputStream.readObject();Dog dog1 = (Dog) dog;System.out.println(dog1);} catch (Exception e) {e.printStackTrace();} finally {// 关闭装饰流，实际会关闭其内部持有的节点流IOUtils.closeQuietly(objectInputStream);}}

对象处理流使用细节

必须读写顺序一致，否则抛出异常；
必须去实现 Serializable 接口，否则抛出异常；
序列化的类中建议添加 serialVersionUID ，为了提高版本的兼容性

    // 序列化的版本号，可以提高兼容性 private static final long serialVersionUID = 1L;

序列化的时候不会序列化 static 或 transient 修饰的字段；

    private static String nation;private transient String color;

序列化的时候，要求里边的属性也必须要实现序列化接口；
序列化有继承性；

2.2.11 标准输入输出流 System.in / System.out

    public static void main(String[] args) {// System.in 编译类型 InputStream// System.in 运行类型 BufferedInputStream// 表示标准输入--键盘System.out.println(System.in.getClass());// System.out 编译类型 PrintStream// System.out 运行类型 PrintStream// 表示标准输出--显示器System.out.println(System.out.getClass());Scanner scanner = new Scanner(System.in);System.out.println("输入内容");String next = scanner.next();System.out.println("next=" + next);}

2.2.12 转换字符输入流 InputStreamReader (防止中文乱码)

转换流可以将字节流转换成字符流

字符编码不统一导致的中文乱码问题

    /*** 测试编码导致的 "中文乱码" 问题*/@Testpublic void test_code_question() {//思路//1. 创建字符输入流 BufferedReader [处理流]//2. 使用 BufferedReader 对象读取文件//3. 默认情况下，读取文件是按照 utf-8 编码String filePath = "src\\main\\resources\\a_gbk.txt";![在这里插入图片描述](https://img-blog.csdnimg.cn/6cb75e4a21f44bf581f772dbaddbe82f.png)BufferedReader bufferedReader = null;try {// 创建 BufferedReaderbufferedReader = new BufferedReader(new FileReader(filePath));// 按行读取，效率高String line;while ((line = bufferedReader.readLine()) != null) {System.out.println(line);}} catch (Exception e) {e.printStackTrace();} finally {// 关闭装饰流，实际会关闭其内部持有的节点流IOUtils.closeQuietly(bufferedReader);}}

文件采用 gbk 的编码方式，内容如下：

因为编码问题到导致的乱码结果

采用转换流解决中文乱码问题

    /*** 使用 InputStreamReader 转换流解决中文乱码问题* 将字节流 FileInputStream 转成字符流 InputStreamReader, 指定编码 gbk*/@Testpublic void test_read_code() {String filePath = "src\\main\\resources\\a_gbk.txt";BufferedReader bufferedReader = null;try {// 把 FileInputStream 转成 InputStreamReader,并指定编码 gbkInputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(filePath), "gbk");// 使用缓冲流，按行读取，效率高(可以不使用)bufferedReader = new BufferedReader(inputStreamReader);String line;while ((line = bufferedReader.readLine()) != null) {System.out.println(line);}} catch (IOException e) {e.printStackTrace();} finally {// 关闭最外层的装饰流，实际会关闭其内部持有的节点流IOUtils.closeQuietly(bufferedReader);}}

转换流指定的编码格式必须和文本编码一致，否则会中文乱码

2.2.13 转换字符输出流 OutputStreamWriter (防止中文乱码)