一、Java IO流的核心概念与体系

Java IO流（Input/Output Stream）是Java标准库中用于处理输入输出的核心机制，通过抽象的”流”模型实现数据在不同介质（如文件、网络、内存）间的传输。其设计遵循装饰器模式，通过组合基础流与包装类实现功能扩展，具有高灵活性与可扩展性。

1.1 IO流的分类体系

Java IO流按数据流向分为输入流（InputStream/Reader）与输出流（OutputStream/Writer），按数据类型分为字节流与字符流，按功能分为节点流（直接操作数据源）与处理流（增强功能）。具体分类如下：

• 字节流：处理二进制数据（如图片、音频），核心类为InputStream/OutputStream
• 字符流：处理文本数据（支持Unicode编码），核心类为Reader/Writer
• 缓冲流：通过缓冲区提升性能（如BufferedInputStream）
• 转换流：实现字节流与字符流的转换（如InputStreamReader）
• 对象流：支持序列化与反序列化（如ObjectInputStream）

1.2 装饰器模式的应用

Java IO通过动态组合实现功能扩展。例如：

// 基础字节流 + 缓冲流 + 对象流
try (FileInputStream fis = new FileInputStream("data.bin");
     BufferedInputStream bis = new BufferedInputStream(fis);
     ObjectInputStream ois = new ObjectInputStream(bis)) {
    Object obj = ois.readObject(); // 反序列化
}

此模式允许开发者按需叠加功能，避免类爆炸问题。

二、核心IO流详解与代码实践

2.1 文件操作流

2.1.1 字节流文件操作

// 字节流写入文件
try (FileOutputStream fos = new FileOutputStream("test.txt")) {
    String content = "Hello, Java IO!";
    fos.write(content.getBytes());
}
// 字节流读取文件
try (FileInputStream fis = new FileInputStream("test.txt")) {
    byte[] buffer = new byte[1024];
    int length = fis.read(buffer);
    System.out.println(new String(buffer, 0, length));
}

2.1.2 字符流文件操作

// 字符流写入文件（自动编码转换）
try (FileWriter writer = new FileWriter("test.txt", StandardCharsets.UTF_8)) {
    writer.write("中文测试");
}
// 字符流读取文件
try (FileReader reader = new FileReader("test.txt", StandardCharsets.UTF_8)) {
    char[] buffer = new char[1024];
    int length = reader.read(buffer);
    System.out.println(new String(buffer, 0, length));
}

2.2 缓冲流优化

缓冲流通过内存缓冲区减少系统调用次数，显著提升性能：

// 缓冲流写入（比直接FileWriter快3-5倍）
try (BufferedWriter bw = new BufferedWriter(
        new FileWriter("large.txt"))) {
    for (int i = 0; i < 10000; i++) {
        bw.write("Line " + i + "\n");
    }
}
// 缓冲流读取
try (BufferedReader br = new BufferedReader(
        new FileReader("large.txt"))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
}

2.3 对象序列化流

对象流支持Java对象的序列化与反序列化：

// 序列化对象
class Person implements Serializable {
    private String name;
    private int age;
    // 构造方法、getter/setter省略
}
try (ObjectOutputStream oos = new ObjectOutputStream(
        new FileOutputStream("person.dat"))) {
    Person p = new Person("张三", 30);
    oos.writeObject(p);
}
// 反序列化对象
try (ObjectInputStream ois = new ObjectInputStream(
        new FileInputStream("person.dat"))) {
    Person p = (Person) ois.readObject();
    System.out.println(p.getName());
}

三、IO流高级应用与最佳实践

3.1 NIO流替代方案

Java NIO（New IO）提供更高效的非阻塞IO模型：

// NIO文件写入示例
Path path = Paths.get("nio.txt");
try (BufferedWriter writer = Files.newBufferedWriter(path)) {
    writer.write("NIO示例");
}
// NIO文件读取
try (BufferedReader reader = Files.newBufferedReader(path)) {
    System.out.println(reader.readLine());
}

3.2 性能优化策略

1. 缓冲区大小选择：通常8KB（8192字节）为最优值
2. 及时关闭资源：使用try-with-resources确保流关闭
3. 减少对象创建：复用缓冲区对象
4. 选择合适流类型：二进制数据用字节流，文本数据用字符流

3.3 异常处理规范

try (InputStream is = new FileInputStream("file.txt")) {
    // 操作代码
} catch (FileNotFoundException e) {
    System.err.println("文件未找到: " + e.getMessage());
} catch (IOException e) {
    System.err.println("IO错误: " + e.getMessage());
}

四、常见问题与解决方案

4.1 中文乱码问题

原因：字符流未指定正确编码
解决方案：

// 正确指定UTF-8编码
try (FileReader reader = new FileReader("chinese.txt", StandardCharsets.UTF_8)) {
    // 读取代码
}

4.2 大文件处理内存溢出

原因：一次性读取整个文件
解决方案：使用缓冲流分块读取：

try (BufferedInputStream bis = new BufferedInputStream(
        new FileInputStream("large.zip"))) {
    byte[] buffer = new byte[8192];
    int bytesRead;
    while ((bytesRead = bis.read(buffer)) != -1) {
        // 处理每个数据块
    }
}

4.3 序列化版本冲突

原因：类结构变更未更新serialVersionUID
解决方案：显式定义版本号：

private static final long serialVersionUID = 1L;

五、总结与学习建议

Java IO流体系是Java开发的基础技能，掌握其核心概念与应用模式对处理文件操作、网络通信等场景至关重要。建议开发者：

1. 从字节流/字符流基础开始，逐步掌握装饰器模式
2. 通过实际项目练习缓冲流、对象流等高级用法
3. 对比NIO与传统IO的适用场景
4. 关注JDK新特性（如Java 11的Files.readString()方法）

附：完整文件复制示例（结合多种IO流）：

public static void copyFile(String source, String target) throws IOException {
    try (BufferedInputStream bis = new BufferedInputStream(
            new FileInputStream(source));
         BufferedOutputStream bos = new BufferedOutputStream(
            new FileOutputStream(target))) {
        byte[] buffer = new byte[8192];
        int bytesRead;
        while ((bytesRead = bis.read(buffer)) != -1) {
            bos.write(buffer, 0, bytesRead);
        }
    }
}

此示例展示了节点流、处理流的组合使用，以及缓冲技术对性能的提升。掌握此类模式可应对80%以上的IO操作场景。