1. 什么是 I/O 流？

在 Java 编程中，I/O 流（Input/Output Stream）是处理输入和输出的核心抽象。它代表了一个有序的数据序列，可以从源（如文件、网络连接、内存缓冲区）读取数据，或向目标写入数据。流的概念屏蔽了底层设备（磁盘、网络、键盘、屏幕等）的差异，让程序员可以用统一的方式处理各种数据源。

简单来说，你可以把流想象成一根“水管”，数据像水一样在管道中单向流动：

• 输入流（InputStream/Reader）：数据从外部源（如文件）流向你的程序。
• 输出流（OutputStream/Writer）：数据从你的程序流向外部目标。

2. 流的分类

Java I/O 流按照不同的维度可以分为以下几类：

2.1 按数据单位：字节流 vs 字符流

简单记忆：带Stream的是字节流，带Reader/Writer的是字符流。

2.2 按功能：节点流 vs 处理流（包装流）

处理流通过装饰器模式实现，可以多层嵌套，例如：

// 一个典型的处理流嵌套：文件 -> 缓冲 -> 字符解码BufferedReaderreader=newBufferedReader(newInputStreamReader(newFileInputStream("data.txt"),"UTF-8"));

3. 核心类与常用 API

3.1 字节流核心类

InputStream 常用方法：

• int read()：读取一个字节，返回 0-255 的 int 值，文件末尾返回 -1。
• int read(byte[] b)：读取最多 b.length 个字节到数组，返回实际读取的字节数。
• int read(byte[] b, int off, int len)：读取 len 个字节到数组的指定位置。
• void close()：关闭流，释放系统资源（必须调用）。

OutputStream 常用方法：

• void write(int b)：写入一个字节（低 8 位）。
• void write(byte[] b)：写入整个字节数组。
• void write(byte[] b, int off, int len)：写入数组的一部分。
• void flush()：强制将缓冲区的数据写入目标（对于缓冲流很重要）。
• void close()：关闭流。

3.2 字符流核心类

Reader 常用方法：

• int read()：读取一个字符，返回 0-65535 的 int 值，末尾返回 -1。
• int read(char[] cbuf)：读取字符到数组。
• int read(CharBuffer target)：读取到 CharBuffer。

Writer 常用方法：

• void write(int c)：写入一个字符。
• void write(char[] cbuf)：写入字符数组。
• void write(String str)：直接写入字符串（非常方便）。
• void flush(),void close()：同字节流。

4. 基础用法示例

4.1 字节流复制文件（基础版）

importjava.io.FileInputStream;importjava.io.FileOutputStream;importjava.io.IOException;publicclassByteStreamCopy{publicstaticvoidmain(String[]args){// 1. 定义源文件和目标文件路径StringsourcePath="source.jpg";StringtargetPath="target_copy.jpg";// 2. 声明流变量（在 try 外声明，便于 finally 关闭）FileInputStreamfis=null;FileOutputStreamfos=null;try{// 3. 创建节点流fis=newFileInputStream(sourcePath);fos=newFileOutputStream(targetPath);// 4. 创建缓冲区（一次读取 8KB）byte[]buffer=newbyte[8192];intbytesRead;// 5. 循环读取并写入while((bytesRead=fis.read(buffer))!=-1){fos.write(buffer,0,bytesRead);// 注意：只写入实际读取的部分}System.out.println("文件复制完成！");}catch(IOExceptione){e.printStackTrace();}finally{// 6. 关闭流（确保资源释放）try{if(fis!=null)fis.close();}catch(IOExceptione){e.printStackTrace();}try{if(fos!=null)fos.close();}catch(IOExceptione){e.printStackTrace();}}}}

4.2 字符流读取文本文件（使用缓冲流提升效率）

importjava.io.BufferedReader;importjava.io.FileReader;importjava.io.IOException;publicclassCharacterStreamRead{publicstaticvoidmain(String[]args){// 使用 try-with-resources 语法，自动关闭资源（Java 7+）try(BufferedReaderbr=newBufferedReader(newFileReader("demo.txt"))){Stringline;while((line=br.readLine())!=null){// 逐行读取System.out.println(line);}}catch(IOExceptione){e.printStackTrace();}// 无需手动调用 close()，try-with-resources 会自动处理}}

4.3 字符流写入文本文件

importjava.io.BufferedWriter;importjava.io.FileWriter;importjava.io.IOException;publicclassCharacterStreamWrite{publicstaticvoidmain(String[]args){// 第二个参数 true 表示追加模式，false（默认）表示覆盖try(BufferedWriterbw=newBufferedWriter(newFileWriter("output.txt",true))){bw.write("Hello, Java I/O!");bw.newLine();// 写入系统相关的行分隔符bw.write("这是第二行。");// 缓冲流通常需要 flush() 确保数据写入，但 close() 会自动调用 flush()}catch(IOExceptione){e.printStackTrace();}}}

5. 高级特性与最佳实践

5.1 使用 try-with-resources 自动管理资源

从 Java 7 开始，所有实现了AutoCloseable接口的流都可以使用try-with-resources语句，确保流被正确关闭，即使发生异常。

// 安全、简洁的写法（推荐）try(FileInputStreamfis=newFileInputStream("source.dat");FileOutputStreamfos=newFileOutputStream("target.dat")){byte[]buffer=newbyte[1024];intlen;while((len=fis.read(buffer))!=-1){fos.write(buffer,0,len);}}catch(IOExceptione){e.printStackTrace();}// 无需 finally 块，流会自动关闭

5.2 缓冲流（Buffered Streams）大幅提升性能

直接使用节点流（如FileInputStream）每次读写一个字节/字符，效率极低。包装一层缓冲流可以将数据先攒在内存缓冲区，批量读写，减少实际的 I/O 操作次数。

// 没有缓冲：每次读写一个字节，性能差FileInputStreamfis=newFileInputStream("largefile.bin");intb;while((b=fis.read())!=-1){// 每次 read() 都是一次系统调用！// 处理 b}// 使用缓冲流：性能提升数十倍甚至上百倍try(BufferedInputStreambis=newBufferedInputStream(newFileInputStream("largefile.bin"))){byte[]buffer=newbyte[8192];intlen;while((len=bis.read(buffer))!=-1){// 一次读取最多 8KB}}

经验法则：处理文件 I/O 时，几乎总是应该使用缓冲流。

5.3 转换流：桥接字节与字符世界

InputStreamReader和OutputStreamWriter是字节流和字符流之间的桥梁。它们负责将字节按照指定的字符集（Charset）解码为字符，或将字符编码为字节。

// 指定 UTF-8 编码读取文本文件（避免平台默认编码导致的乱码）try(BufferedReaderreader=newBufferedReader(newInputStreamReader(newFileInputStream("data.txt"),StandardCharsets.UTF_8))){// 明确指定字符集Stringline;while((line=reader.readLine())!=null){System.out.println(line);}}

5.4 对象序列化流（ObjectInputStream / ObjectOutputStream）

可以将实现了Serializable接口的 Java 对象转换为字节序列（序列化）保存到文件或网络，也可以从字节序列恢复对象（反序列化）。

importjava.io.*;classPersonimplementsSerializable{privateStringname;privateintage;// 构造方法、getter/setter 省略}publicclassObjectStreamDemo{publicstaticvoidmain(String[]args){Personperson=newPerson("张三",25);// 序列化对象到文件try(ObjectOutputStreamoos=newObjectOutputStream(newFileOutputStream("person.dat"))){oos.writeObject(person);System.out.println("对象已序列化保存。");}catch(IOExceptione){e.printStackTrace();}// 从文件反序列化对象try(ObjectInputStreamois=newObjectInputStream(newFileInputStream("person.dat"))){PersonrestoredPerson=(Person)ois.readObject();System.out.println("恢复的对象: "+restoredPerson.getName()+", "+restoredPerson.getAge());}catch(IOException|ClassNotFoundExceptione){e.printStackTrace();}}}

注意：

• transient关键字修饰的字段不会被序列化。
• 反序列化不会调用类的构造方法。
• 序列化版本号serialVersionUID用于验证版本一致性，建议显式声明。

6. 常见问题与陷阱

1. 忘记关闭流：导致资源（文件句柄、网络连接）泄漏。务必使用 try-with-resources。
2. 未调用flush()：对于缓冲输出流，在关闭前或需要立即写入时，应调用flush()。
3. 字符编码问题：读写文本时未指定字符集，在不同平台可能产生乱码。始终明确指定字符集（如StandardCharsets.UTF_8）。
4. 混淆read()的返回值：InputStream.read()返回int（0-255），不是byte，文件末尾返回 -1。
5. 错误使用write(byte[])：写入字节数组时，如果读取长度小于数组长度，应使用write(buffer, 0, len)，而不是write(buffer)，否则会写入无效数据。
6. 性能问题：对小文件使用大缓冲区浪费内存，对大文件使用小缓冲区或不用缓冲流则性能低下。通常 8KB (8192 bytes) 是一个较好的折中。

7. NIO.2（Java 7+）的增强

Java 7 引入了 NIO.2（java.nio.file包），提供了更现代、功能更强的文件 I/O API。虽然传统的 I/O 流依然重要且常用，但在某些场景下 NIO.2 更便捷：

• Files工具类：提供了读写文件的静态方法，一行代码完成常见操作。

  // 读取所有行（自动处理编码和资源关闭）List<String>lines=Files.readAllLines(Paths.get("file.txt"),StandardCharsets.UTF_8);// 写入字符串Files.write(Paths.get("output.txt"),"content".getBytes(StandardCharsets.UTF_8));

• Path接口：比File类更强大、更不易出错。
• 异步 I/O：支持非阻塞操作，适合高并发场景。

8. 总结

Java I/O 流体系庞大但层次清晰。掌握它的关键是理解字节流/字符流、节点流/处理流这两组核心分类，并熟练运用缓冲流、try-with-resources和明确的字符编码这三大最佳实践。

对于大多数日常文件操作，推荐组合：

• 读文本文件：BufferedReader+InputStreamReader+FileInputStream（指定字符集）。
• 写文本文件：BufferedWriter+OutputStreamWriter+FileOutputStream（指定字符集）。
• 复制二进制文件：BufferedInputStream+FileInputStream和BufferedOutputStream+FileOutputStream。

随着 Java 版本更新，虽然出现了 NIO.2 等更现代的 API，但传统的 I/O 流由于其简单、直观的特性，在众多场景下依然是不可或缺的基础。理解其原理和正确用法，是每一位 Java 开发者的必修课。