一、Java IO体系全景图

Java IO（Input/Output）是Java语言中处理数据输入输出的核心模块，其设计遵循”流式处理”理念，将数据抽象为连续的字节或字符序列。从JDK 1.0到NIO（New IO）的演进，Java IO形成了包含传统IO、NIO、NIO.2三大模块的完整体系。

1.1 核心分类与演进

模块	引入版本	核心特性	适用场景
传统IO	JDK 1.0	同步阻塞，面向流	小文件、简单IO操作
NIO	JDK 1.4	同步非阻塞，面向缓冲区	大文件、高并发网络IO
NIO.2	JDK 1.7	异步非阻塞，文件系统API增强	复杂文件操作、异步IO

二、传统IO核心组件详解

2.1 字节流与字符流

Java IO将流分为字节流（处理二进制数据）和字符流（处理文本数据），两者通过装饰器模式实现功能扩展。

2.1.1 字节流体系

// 文件读取示例
try (FileInputStream fis = new FileInputStream("input.txt");
     BufferedInputStream bis = new BufferedInputStream(fis)) {
    int data;
    while ((data = bis.read()) != -1) {
        System.out.print((char) data);
    }
}

关键组件：

• InputStream/OutputStream：抽象基类
• FileInputStream/FileOutputStream：文件操作
• BufferedInputStream/BufferedOutputStream：带缓冲的流
• DataInputStream/DataOutputStream：基本数据类型读写

2.1.2 字符流体系

// 文件写入示例
try (FileReader fr = new FileReader("input.txt");
     BufferedReader br = new BufferedReader(fr);
     FileWriter fw = new FileWriter("output.txt");
     PrintWriter pw = new PrintWriter(fw)) {
    String line;
    while ((line = br.readLine()) != null) {
        pw.println(line.toUpperCase());
    }
}

字符编码处理：

// 指定UTF-8编码
try (InputStreamReader isr = new InputStreamReader(
        new FileInputStream("input.txt"), StandardCharsets.UTF_8);
     OutputStreamWriter osw = new OutputStreamWriter(
        new FileOutputStream("output.txt"), StandardCharsets.UTF_8)) {
    // 处理字符数据
}

2.2 管道流与对象流

2.2.1 管道流（Piped Stream）

// 线程间通信示例
PipedInputStream pis = new PipedInputStream();
PipedOutputStream pos = new PipedOutputStream(pis);
new Thread(() -> {
    try {
        pos.write("Hello".getBytes());
    } catch (IOException e) {
        e.printStackTrace();
    }
}).start();
new Thread(() -> {
    try {
        int data;
        while ((data = pis.read()) != -1) {
            System.out.print((char) data);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}).start();

2.2.2 对象流（Object Stream）

// 对象序列化示例
try (ObjectOutputStream oos = new ObjectOutputStream(
        new FileOutputStream("object.dat"));
     ObjectInputStream ois = new ObjectInputStream(
        new FileInputStream("object.dat"))) {
    // 序列化
    oos.writeObject(new Person("张三", 25));
    // 反序列化
    Person p = (Person) ois.readObject();
}

序列化要求：

1. 类实现Serializable接口
2. 字段建议使用transient修饰敏感数据
3. 自定义序列化可通过writeObject/readObject实现

三、NIO核心特性解析

3.1 缓冲区（Buffer）

// ByteBuffer使用示例
ByteBuffer buffer = ByteBuffer.allocate(1024);
buffer.put("Hello".getBytes());
buffer.flip(); // 切换为读模式
while (buffer.hasRemaining()) {
    System.out.print((char) buffer.get());
}
buffer.clear(); // 重置缓冲区

Buffer核心属性：

• Capacity：缓冲区容量
• Position：当前读写位置
• Limit：读写边界

3.2 通道（Channel）

// 文件通道示例
try (FileChannel inChannel = FileChannel.open(
        Paths.get("input.txt"), StandardOpenOption.READ);
     FileChannel outChannel = FileChannel.open(
        Paths.get("output.txt"), StandardOpenOption.WRITE, 
        StandardOpenOption.CREATE)) {
    // 通道间数据传输
    inChannel.transferTo(0, inChannel.size(), outChannel);
}

Channel类型：

• FileChannel：文件操作
• SocketChannel：TCP网络通信
• DatagramChannel：UDP网络通信
• ServerSocketChannel：服务器端Socket

3.3 选择器（Selector）

// 选择器示例
Selector selector = Selector.open();
SocketChannel socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false);
socketChannel.register(selector, SelectionKey.OP_READ);
while (true) {
    int readyChannels = selector.select();
    if (readyChannels == 0) continue;
    Set<SelectionKey> selectedKeys = selector.selectedKeys();
    Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
    while (keyIterator.hasNext()) {
        SelectionKey key = keyIterator.next();
        if (key.isReadable()) {
            // 处理读事件
        }
        keyIterator.remove();
    }
}

四、NIO.2文件系统API

4.1 Path与Files类

// 文件操作示例
Path path = Paths.get("/tmp/test.txt");
// 创建文件
Files.createFile(path);
// 读取文件
List<String> lines = Files.readAllLines(path, StandardCharsets.UTF_8);
// 写入文件
Files.write(path, "Hello".getBytes(), StandardOpenOption.APPEND);
// 文件属性
BasicFileAttributes attrs = Files.readAttributes(
    path, BasicFileAttributes.class);
System.out.println("创建时间: " + attrs.creationTime());

4.2 异步文件通道

// 异步文件写入
AsynchronousFileChannel fileChannel = 
    AsynchronousFileChannel.open(path, StandardOpenOption.WRITE);
ByteBuffer buffer = ByteBuffer.wrap("Hello".getBytes());
fileChannel.write(buffer, 0, null, new CompletionHandler<Integer, Object>() {
    @Override
    public void completed(Integer result, Object attachment) {
        System.out.println("写入完成");
    }
    @Override
    public void failed(Throwable exc, Object attachment) {
        exc.printStackTrace();
    }
});

五、性能优化实践

5.1 缓冲策略优化

策略	适用场景	性能提升
缓冲流	小数据量频繁IO	2-5倍
直接缓冲区	大文件处理	10-20%
内存映射文件	随机访问大文件	50%+

5.2 零拷贝技术

// 使用FileChannel.transferTo实现零拷贝
FileChannel source = FileChannel.open(Paths.get("input.txt"));
FileChannel dest = FileChannel.open(Paths.get("output.txt"), 
    StandardOpenOption.WRITE, StandardOpenOption.CREATE);
source.transferTo(0, source.size(), dest);

零拷贝优势：

• 减少数据在内核空间与用户空间的拷贝
• 降低CPU缓存污染
• 提升大文件传输效率

5.3 选择器最佳实践

1. 每个线程一个Selector
2. 合理设置超时时间（selector.select(timeout)）
3. 避免在事件处理中执行耗时操作
4. 使用SelectionKey.interestOps()动态调整关注事件

六、常见问题解决方案

6.1 文件锁冲突

// 独占文件锁示例
try (FileChannel channel = FileChannel.open(path, 
        StandardOpenOption.READ, StandardOpenOption.WRITE);
     FileLock lock = channel.lock()) {
    // 临界区代码
} catch (OverlappingFileLockException e) {
    // 处理重复加锁
}

6.2 内存泄漏防范

1. 及时关闭流和通道（使用try-with-resources）
2. 避免直接缓冲区泄漏
3. 监控DirectBuffer内存使用（BufferPoolMXBean）

6.3 大文件处理技巧

1. 分块读取（建议每次4KB-8KB）
2. 使用内存映射文件处理超大文件
3. 考虑使用RandomAccessFile进行随机访问

七、总结与展望

Java IO体系经过多年演进，形成了从同步阻塞到异步非阻塞的完整解决方案。开发者应根据具体场景选择合适的技术：

• 小文件/简单操作：传统IO
• 大文件/高并发：NIO
• 复杂文件操作：NIO.2
• 极高并发：Netty等NIO框架

未来随着AIO（异步IO）的完善和项目Loom对虚拟线程的支持，Java IO将迎来新的性能突破。掌握当前IO体系的核心原理，将为应对未来技术变革打下坚实基础。

（全文约3200字，涵盖Java IO核心概念、代码示例、性能优化及问题解决方案）