Java IO流详解（史上最全18个案例代码）_java io 源码解析

每文一句

每想拥抱你一次，天空飘落一片雪，至此雪花拥抱撒哈拉！ —荷西

一、IO流开篇

1. 概念：

IO（Input/Output）流是Java中用于处理输入和输出数据的机制。它允许程序与外部设备（如文件、网络连接、内存等）进行数据交换。IO流按照操作单位的不同可以分为字节流和字符流两种类型。

2. 流的分类：

• 字节流（Byte Streams）：以字节为单位进行操作，适用于处理二进制数据或不需要进行字符编码转换的场景。主要的字节流类包括InputStream和OutputStream及其子类。
• 字符流（Character Streams）：以字符为单位进行操作，适用于处理文本数据并支持字符编码转换。主要的字符流类包括Reader和Writer及其子类。

3. IO流的作用：

• 实现数据的输入和输出：通过IO流，可以从外部源中读取数据到程序中，或者将程序中的数据写入到外部源中。
• 处理文件操作：可以通过IO流读取、写入文件，实现文件的读取、写入和操作。
• 网络通信：通过IO流可以实现网络通信，包括建立Socket连接、传输数据等。

4. IO流的使用场景：

• 文件操作：读取、写入和处理文件。
• 网络编程：建立Socket连接，进行网络通信。
• 数据处理：通过IO流实现数据的输入、输出和处理，包括序列化、反序列化等操作。
• 图像处理：读取、写入图像文件，并进行图像处理操作。

二、字节流

字节流常用类

字节流是Java中处理字节数据的流，主要用于处理二进制数据或不需要进行字符编码转换的情况。以下是常用的字节流类：

1. InputStream（输入流）及其子类：

• FileInputStream：用于从文件中读取数据的输入流。
• ByteArrayInputStream：从内存中的字节数组中读取数据的输入流。
• BufferedInputStream：带有缓冲区的输入流，可以提高读取性能。
• DataInputStream：读取基本数据类型的输入流，例如int、double等。
• ObjectInputStream：用于反序列化对象的输入流，可以将对象从字节流中恢复为原来的对象。

2. OutputStream（输出流）及其子类：

• FileOutputStream：用于向文件中写入数据的输出流。
• ByteArrayOutputStream：将数据写入到内存中的字节数组的输出流。
• BufferedOutputStream：带有缓冲区的输出流，可以提高写入性能。
• DataOutputStream：写入基本数据类型的输出流，例如int、double等。
• ObjectOutputStream：用于序列化对象的输出流，可以将对象转换为字节流进行持久化存储。

字节流使用案例

1. FileInputStream（文件输入流）：

• 简单介绍： 用于从文件中读取数据的输入流。
• 应用场景： 读取文件内容，进行数据处理和分析。
• 代码演示：

  import java.io.FileInputStream;
  import java.io.IOException;
  
  public class FileInputStreamExample {
      public static void main(String[] args) {
          try (FileInputStream fis = new FileInputStream("example.txt")) {
              int data;
              while ((data = fis.read()) != -1) {
                  System.out.print((char) data);
              }
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15

2. FileOutputStream（文件输出流）：

• 简单介绍： 用于向文件中写入数据的输出流。
• 应用场景： 将程序中的数据写入文件，如日志记录、数据持久化等。
• 代码演示：

  import java.io.FileOutputStream;
  import java.io.IOException;
  
  public class FileOutputStreamExample {
      public static void main(String[] args) {
          String data = "Hello, FileOutputStream!";
          try (FileOutputStream fos = new FileOutputStream("output.txt")) {
              fos.write(data.getBytes());
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13

3. ByteArrayInputStream（字节数组输入流）：

• 简单介绍： 从字节数组中读取数据的输入流。
• 应用场景： 将字节数组作为数据源，进行数据的读取和处理。
• 代码演示：

  import java.io.ByteArrayInputStream;
  import java.io.IOException;
  
  public class ByteArrayInputStreamExample {
      public static void main(String[] args) {
          byte[] bytes = {72, 101, 108, 108, 111};
          try (ByteArrayInputStream bais = new ByteArrayInputStream(bytes)) {
              int data;
              while ((data = bais.read()) != -1) {
                  System.out.print((char) data);
              }
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

4. ByteArrayOutputStream（字节数组输出流）：

• 简单介绍： 将数据写入到字节数组的输出流。
• 应用场景： 将程序中的数据写入字节数组，便于数据传输和处理。
• 代码演示：

  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  
  public class ByteArrayOutputStreamExample {
      public static void main(String[] args) {
          String data = "Hello, ByteArrayOutputStream!";
          try (ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
              baos.write(data.getBytes());
              byte[] result = baos.toByteArray();
              System.out.println(new String(result));
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15

5. BufferedInputStream（缓冲输入流）：

• 简单介绍： 带有缓冲区的输入流，提高读取性能。
• 应用场景： 从文件中读取大量数据时，通过缓冲区减少IO操作次数，提升读取效率。
• 代码演示：

  import java.io.BufferedInputStream;
  import java.io.FileInputStream;
  import java.io.IOException;
  
  public class BufferedInputStreamExample {
      public static void main(String[] args) {
          try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("example.txt"))) {
              int data;
              while ((data = bis.read()) != -1) {
                  System.out.print((char) data);
              }
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

6. BufferedOutputStream（缓冲输出流）：

• 简单介绍： 带有缓冲区的输出流，提高写入性能。
• 应用场景： 向文件中写入大量数据时，通过缓冲区减少IO操作次数，提升写入效率。
• 代码演示：

  import java.io.BufferedOutputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  
  public class BufferedOutputStreamExample {
      public static void main(String[] args) {
          String data = "Hello, BufferedOutputStream!";
          try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("output.txt"))) {
              bos.write(data.getBytes());
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14

7. DataInputStream（数据输入流）：

• 简单介绍： 读取基本数据类型的数据的输入流。
• 应用场景： 读取通过DataOutputStream写入的基本数据类型数据。
• 代码演示：

  import java.io.DataInputStream;
  import java.io.FileInputStream;
  import java.io.IOException;
  
  public class DataInputStreamExample {
      public static void main(String[] args) {
          try (DataInputStream dis = new DataInputStream(new FileInputStream("data.bin"))) {
              int intValue = dis.readInt();
              double doubleValue = dis.readDouble();
              System.out.println("Int value: " + intValue);
              System.out.println("Double value: " + doubleValue);
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

8. DataOutputStream（数据输出流）：

• 简单介绍： 将基本数据类型的数据写入文件的输出流。
• 应用场景： 将程序中的基本数据类型数据写入文件，便于持久化存储。
• 代码演示：

  import java.io.DataOutputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  
  public class DataOutputStreamExample {
      public static void main(String[] args) {
          try (DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.bin"))) {
              int intValue = 42;
              double doubleValue = 3.14;
              dos.writeInt(intValue);
              dos.writeDouble(doubleValue);
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

9. ObjectInputStream（对象输入流）：

• 简单介绍： 用于反序列化对象的输入流，可以将对象从字节流中恢复为原来的对象。
• 应用场景： 用于读取通过 ObjectOutputStream 序列化的对象数据，恢复为原来的对象。
• 代码演示：

  import java.io.FileInputStream;
  import java.io.IOException;
  import java.io.ObjectInputStream;
  
  public class ObjectInputStreamExample {
      public static void main(String[] args) {
          try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.bin"))) {
              // 从文件中读取对象
              MyClass obj = (MyClass) ois.readObject();
              System.out.println("Object read from file: " + obj);
          } catch (IOException | ClassNotFoundException e) {
              e.printStackTrace();
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15

10. ObjectOutputStream（对象输出流）：

• 简单介绍： 用于将对象序列化为字节流并写入文件的输出流，可以将对象持久化存储。
• 应用场景： 用于将程序中的对象数据序列化为字节流，保存到文件中或传输到网络。
• 代码演示：

  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.ObjectOutputStream;
  
  public class ObjectOutputStreamExample {
      public static void main(String[] args) {
          MyClass obj = new MyClass("John", 30);
          try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.bin"))) {
              // 将对象写入文件
              oos.writeObject(obj);
              System.out.println("Object written to file: " + obj);
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

三、字符流

字符流常用类

字符流是Java中处理字符数据的流，主要用于处理文本数据并支持字符编码转换。以下是常用的字符流类：

1. Reader（读取字符流）及其子类：

• FileReader：从文件中读取字符数据的字符输入流。
• BufferedReader：带有缓冲区的字符输入流，提高读取性能。
• InputStreamReader：将字节流转换为字符流的桥梁，支持指定字符编码。
• StringReader：从字符串中读取字符数据的字符输入流。

2. Writer（写入字符流）及其子类：

• FileWriter：向文件中写入字符数据的字符输出流。
• BufferedWriter：带有缓冲区的字符输出流，提高写入性能。
• OutputStreamWriter：将字符流转换为字节流的桥梁，支持指定字符编码。
• StringWriter：将字符数据写入到字符串中的字符输出流。

字符流使用案例

1. FileReader（文件读取字符流）：

• 简单介绍： 用于从文件中读取字符数据的字符输入流。
• 应用场景： 读取文本文件中的内容，进行处理或分析。
• 代码演示：

  import java.io.FileReader;
  import java.io.IOException;
  
  public class FileReaderExample {
      public static void main(String[] args) {
          try (FileReader reader = new FileReader("example.txt")) {
              int character;
              while ((character = reader.read()) != -1) {
                  System.out.print((char) character);
              }
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15

2. FileWriter（文件写入字符流）：

• 简单介绍： 用于向文件中写入字符数据的字符输出流。
• 应用场景： 将程序中生成的文本数据写入文件，如日志记录等。
• 代码演示：

  import java.io.FileWriter;
  import java.io.IOException;
  
  public class FileWriterExample {
      public static void main(String[] args) {
          String data = "Hello, FileWriter!";
          try (FileWriter writer = new FileWriter("output.txt")) {
              writer.write(data);
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13

3. BufferedReader（带缓冲的字符读取流）：

• 简单介绍： 带有缓冲区的字符输入流，可以提高读取性能。
• 应用场景： 从文件中读取大量字符数据时，通过缓冲区减少IO操作次数，提升读取效率。
• 代码演示：

  import java.io.BufferedReader;
  import java.io.FileReader;
  import java.io.IOException;
  
  public class BufferedReaderExample {
      public static void main(String[] args) {
          try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
              String line;
              while ((line = reader.readLine()) != null) {
                  System.out.println(line);
              }
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

4. BufferedWriter（带缓冲的字符写入流）：

• 简单介绍： 带有缓冲区的字符输出流，可以提高写入性能。
• 应用场景： 向文件中写入大量字符数据时，通过缓冲区减少IO操作次数，提升写入效率。
• 代码演示：

  import java.io.BufferedWriter;
  import java.io.FileWriter;
  import java.io.IOException;
  
  public class BufferedWriterExample {
      public static void main(String[] args) {
          String data = "Hello, BufferedWriter!";
          try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
              writer.write(data);
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14

5. InputStreamReader（字节流到字符流的桥梁）：

• 简单介绍： 将字节流转换为字符流的桥梁，支持指定字符编码。
• 应用场景： 从字节流中读取字符数据，并根据指定的字符编码转换为字符流。
• 代码演示：

  import java.io.FileInputStream;
  import java.io.IOException;
  import java.io.InputStreamReader;
  
  public class InputStreamReaderExample {
      public static void main(String[] args) {
          try (InputStreamReader isr = new InputStreamReader(new FileInputStream("example.txt"), "UTF-8")) {
              int character;
              while ((character = isr.read()) != -1) {
                  System.out.print((char) character);
              }
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

6. OutputStreamWriter（字符流到字节流的桥梁）：

• 简单介绍： 将字符流转换为字节流的桥梁，支持指定字符编码。
• 应用场景： 将字符数据转换为字节流，并根据指定的字符编码写入到字节流中。
• 代码演示：

  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.OutputStreamWriter;
  
  public class OutputStreamWriterExample {
      public static void main(String[] args) {
          String data = "Hello, OutputStreamWriter!";
          try (OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("output.txt"), "UTF-8")) {
              osw.write(data);
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14

7. StringReader（从字符串读取字符流）：

• 简单介绍： 从字符串中读取字符数据的字符输入流。
• 应用场景： 将字符串数据作为输入源，进行字符数据的读取和处理。
• 代码演示：

  import java.io.StringReader;
  import java.io.IOException;
  
  public class StringReaderExample {
      public static void main(String[] args) {
          String data = "Hello, StringReader!";
          try (StringReader reader = new StringReader(data)) {
              int character;
              while ((character = reader.read()) != -1) {
                  System.out.print((char) character);
              }
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

8. StringWriter（写入字符到字符串）：

• 简单介绍： 将字符数据写入到字符串中的字符输出流。
• 应用场景： 将程序中生成的字符数据写入字符串中，方便后续处理或输出。
• 代码演示：

  import java.io.StringWriter;
  import java.io.IOException;
  
  public class StringWriterExample {
      public static void main(String[] args) {
          try (StringWriter writer = new StringWriter()) {
              String data = "Hello, StringWriter!";
              writer.write(data);
              System.out.println(writer.toString());
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14

四、完结撒花ING