Java 从入门到精通（十三）：NIO 与高效文件读写，为什么 Java 后来还要再造一套 IO？

前一篇我们把 File、字节流、字符流、缓冲流这些基础 IO 骨架搭起来了。

如果只是做入门练习，很多人学到这里会觉得：

“差不多够用了，文件能读，文件能写，为什么 Java 后来还要再搞一套 NIO？”

这恰恰是很多人学 Java IO 时最容易忽略的一步。

因为传统 IO 当然能用，但它并不总是高效，也不总是适合现代工程场景。

当你开始面对下面这些问题时，老 IO 的局限就会越来越明显：

• 文件越来越大，复制和读取越来越慢
• 需要处理很多目录和路径，字符串拼接越来越乱
• 想一次性读写更复杂的二进制数据，代码又长又容易错
• 想做高并发网络编程，线程一多系统就开始吃不消
• 想更优雅地处理文件遍历、文件属性、批量操作，发现老 API 很别扭

也正因为这样，Java 从 JDK 1.4 开始引入了 NIO（New IO），后面又在 JDK 7 进一步补强了 NIO.2。

所以这篇文章要解决的，不是“多背几个新类名”，而是把这几个问题讲明白：

• NIO 到底是在解决什么问题？
• 它和传统 IO 的差别到底在哪里？
• Path、Files、Buffer、Channel、Selector 分别是什么角色？
• 在日常开发里，哪些文件操作应该优先用 NIO？
• 真正写代码时，怎样判断自己该用老 IO 还是 NIO？

---

一、先说结论：NIO 不只是“新的 IO 写法”，而是抽象层次变了

很多初学者第一次看 NIO，会误以为它只是把 FileInputStream 换成了 Files.readAllBytes()，或者把 File 换成了 Path。

这理解太浅了。

NIO 真正重要的地方在于：

它不只是换 API，而是重新定义了“数据怎么流动、资源怎么表示、程序怎么和操作系统打交道”。

传统 IO 的核心思路更像是：

• 面向流（stream）
• 程序一点点读，一点点写
• 读写过程往往和线程阻塞绑定得很紧

而 NIO 的核心思路更偏向：

• 面向缓冲区（buffer）
• 面向通道（channel）
• 更强调批量、高效、可管理的数据搬运
• 在网络场景下支持非阻塞和多路复用

所以，NIO 不只是“新”，而是更接近现代操作系统和高性能程序的思维方式。

---

二、为什么传统 IO 在工程里会慢慢不够用

先别急着学新类名，先看老问题。

传统 IO 的典型风格是这样的：

• 打开一个输入流
• 打开一个输出流
• 准备一个 byte 数组当缓冲区
• 用 while 循环不断读写
• 最后记得关流

这种方式当然没错，而且很多场景下依然够用。

但它有几个天然局限。

1）抽象偏底层，代码容易样板化

你会发现很多文件复制、文本读取、目录处理代码，结构都差不多：

• 创建流
• 循环读
• 循环写
• 处理异常
• 关闭资源

重复多了之后，代码会越来越啰嗦。

2）路径处理不够优雅

老的 File 类虽然常用，但路径拼接、跨平台兼容、目录遍历、属性读取这些事情写起来都不算顺手。

比如：

• Windows 和 Linux 的路径分隔符不同
• 相对路径和绝对路径容易混
• 判断路径存在、是否目录、是否可读，经常要一串 if

3）大文件与高性能场景支持一般

对于大文件复制、批量读写、零拷贝思路、内存映射文件等需求，传统 IO 就不够舒服了。

4）网络高并发场景扩展性差

在老 BIO 模式下，一个连接往往对应一个线程。

连接数一上来，线程切换、阻塞等待、内存开销就都会成为问题。

这也是为什么后面 Netty、NIO Reactor 这条线会越来越重要。

---

三、NIO 里最核心的五个角色，一次讲清

如果你第一次学 NIO，我建议先把它理解成五个关键角色：

• Path
• Files
• Buffer
• Channel
• Selector

不是每个项目都会同时用到这五个，但如果这几个角色关系不清楚，后面很容易越学越乱。

---

四、Path：以后别再把路径只当字符串用了

在传统写法里，很多人习惯直接拿字符串表示路径：

String path = "data/test.txt";

这当然能用，但问题是：

• 字符串本身不懂“路径”
• 它不会帮你处理路径拼接语义
• 它也不会直接告诉你这是文件还是目录

NIO 里更推荐用 Path：

Path path = Paths.get("data", "test.txt");

Path 的好处不是“更高级”，而是它更像真正的路径对象。

你可以很自然地做这些事：

• 拼接路径
• 取父目录
• 取文件名
• 转绝对路径
• 规范化路径

例如：

Path base = Paths.get("data");
Path file = base.resolve("test.txt");
System.out.println(file.toAbsolutePath());

这里的 resolve() 比字符串拼接稳得多。

Path 相关常见操作

Path path = Paths.get("logs", "app.log");

System.out.println(path.getFileName());
System.out.println(path.getParent());
System.out.println(path.toAbsolutePath());
System.out.println(path.normalize());

如果你现在还在大量手写 "/" + 文件名 这种路径拼接，基本就说明代码还停留在比较原始的阶段。

---

五、Files：文件操作从“手搓流程”变成“直接表达意图”

如果说 Path 是更好的路径表示，那么 Files 就是在告诉你：

很多常见文件操作，别再自己一层层手写了。

例如判断文件是否存在：

Path path = Paths.get("data", "note.txt");

if (Files.exists(path)) {
    System.out.println("文件存在");
}

读取整个文件内容：

String content = Files.readString(path);
System.out.println(content);

写入文件：

Files.writeString(path, "hello nio");

读取所有行：

List<String> lines = Files.readAllLines(path);
for (String line : lines) {
    System.out.println(line);
}

复制文件：

Path source = Paths.get("data", "a.txt");
Path target = Paths.get("backup", "a.txt");

Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);

移动文件：

Files.move(source, target, StandardCopyOption.REPLACE_EXISTING);

删除文件：

Files.deleteIfExists(path);

这些 API 最大的价值，不只是代码变短，而是语义更清楚。

你是在“读字符串”、还是“复制文件”、还是“删除路径”，一眼就能看出来。

这就是抽象层次提升带来的好处。

---

六、Buffer：NIO 为什么强调“缓冲区”

很多人学到这里最容易卡住的，就是 Buffer。

因为在传统 IO 里，你虽然也会写 byte[] buffer = new byte[1024];，但你不会把“缓冲区”当成一个正式的核心抽象。

而在 NIO 里，Buffer 是主角之一。

常见的有：

• ByteBuffer
• CharBuffer
• IntBuffer

其中最常用的是 ByteBuffer。

为什么要有 Buffer？

因为 NIO 的很多读写动作，不再是“流一边读，程序一边拿”，而是：

• 先把数据读到一个缓冲区
• 再从缓冲区取数据处理
• 或者先把数据写进缓冲区，再统一刷出去

这让数据处理过程变得更清晰，也更接近底层系统的工作方式。

ByteBuffer 最重要的几个状态

学 ByteBuffer，一定要理解这几个概念：

• capacity：总容量
• position：当前读写位置
• limit：当前可读/可写边界

很多人 NIO 学不会，不是不会写代码，而是没理解这三个指标怎么变。

例如：

ByteBuffer buffer = ByteBuffer.allocate(1024);
System.out.println(buffer.position());
System.out.println(buffer.limit());
System.out.println(buffer.capacity());

初始状态下：

• position = 0
• limit = capacity

写入一些数据后，position 会往后移动。

当你准备“从写模式切换到读模式”时，要调用：

buffer.flip();

这一步非常关键。

为什么 flip() 这么重要？

因为 flip() 的作用是：

• 把 limit 设为当前 position
• 把 position 重置为 0

也就是说，它告诉缓冲区：

“刚才写到这里为止，现在我要从头开始读你已经写好的内容了。”

如果你忘了 flip()，后面读数据时大概率就会出错，或者读不到预期内容。

这是 NIO 新手最经典的坑之一。

一个简单示例

ByteBuffer buffer = ByteBuffer.allocate(20);

buffer.put("hello".getBytes());
buffer.flip();

while (buffer.hasRemaining()) {
    System.out.print((char) buffer.get());
}

输出：

hello

这里如果不 flip()，读取逻辑就不对了。

---

七、Channel：为什么说 NIO 更像“数据通道”而不是“数据水流”

传统 IO 强调的是流：InputStream、OutputStream、Reader、Writer。

NIO 里更强调 Channel。

常见有：

• FileChannel
• SocketChannel
• ServerSocketChannel

你可以把它理解成：

程序和文件、网络连接之间的一条数据通道。

例如文件通道：

try (FileInputStream fis = new FileInputStream("data.txt");
     FileChannel channel = fis.getChannel()) {

    ByteBuffer buffer = ByteBuffer.allocate(1024);
    int bytesRead = channel.read(buffer);
    System.out.println(bytesRead);
}

这里的 channel.read(buffer) 本质上是把数据读进缓冲区。

Channel 和 Stream 的直觉差异

可以这样粗略记：

• Stream 更像“顺着水流读写”
• Channel 更像“通过通道把数据搬进搬出”

NIO 的强项之一，就是 Channel + Buffer 这套配合方式。

---

八、FileChannel 在文件处理里到底强在哪

如果你做的是文件读写，最常遇到的 NIO 通道就是 FileChannel。

它的优势主要有几类。

1）更适合和 Buffer 配合

你可以更明确地控制数据读取和写出的过程。

2）支持更底层、更高效的文件操作

比如获取文件位置、设置位置、部分读写等。

3）支持 transferTo / transferFrom

这是文件复制里一个很值得注意的点。

例如：

try (FileChannel from = FileChannel.open(Paths.get("a.txt"), StandardOpenOption.READ);
     FileChannel to = FileChannel.open(Paths.get("b.txt"),
             StandardOpenOption.CREATE,
             StandardOpenOption.WRITE,
             StandardOpenOption.TRUNCATE_EXISTING)) {

    from.transferTo(0, from.size(), to);
}

这种写法的意义不只是“代码更短”，更重要的是它可能利用底层机制做更高效的数据传输。

很多人第一次听到“零拷贝”这个词，就是从这里开始接触的。

当然，底层是否真正做到零拷贝、做到什么程度，还和操作系统实现有关，但从 Java 代码层面，这已经是更现代的思路。

---

九、NIO.2 为什么让日常文件操作体验提升很大

如果说早期 NIO 更偏底层，那么 JDK 7 引入的 NIO.2 更像是把“文件系统操作”这件事真正做顺手了。

日常开发里，最常直接受益的其实是这些能力：

• Path
• Files
• 文件属性读取
• 目录遍历
• walkFileTree

例如遍历目录：

Path dir = Paths.get("data");

try (Stream<Path> paths = Files.list(dir)) {
    paths.forEach(System.out::println);
}

递归遍历：

try (Stream<Path> paths = Files.walk(Paths.get("data"))) {
    paths.forEach(System.out::println);
}

这比老式自己套目录判断和递归代码舒服太多。

读取文件属性

long size = Files.size(Paths.get("data.txt"));
System.out.println(size);

或者：

boolean isDirectory = Files.isDirectory(Paths.get("data"));
boolean readable = Files.isReadable(Paths.get("data.txt"));

这类 API 很适合写工程代码时做前置校验。

---

十、网络编程里，NIO 真正厉害的地方是非阻塞和多路复用

如果只做文件操作，你已经会觉得 NIO 挺有用了。

但它真正拉开层次差距的地方，其实是在网络编程。

传统 BIO 模式通常是：

• 一个连接一个线程
• 读不到数据时线程阻塞等待

这种模式简单直观，但连接数大了就扛不住。

NIO 提供了非阻塞能力。

也就是说，一个线程不必傻等某个连接的数据读完，而是可以：

• 先注册多个通道
• 由 Selector 统一监听哪些通道“准备好了”
• 再只处理那些当前真正有事件的连接

这背后就是多路复用思路。

这也是为什么高性能网络框架，比如 Netty，本质上都建立在 NIO 之上。

Selector 你现在要记住什么？

如果你还是 Java 基础阶段，不需要一上来就把 Reactor 模式啃透。

先记住一句最重要的话：

Selector 的作用，是让一个线程有机会管理多个网络通道，而不是为每个连接都单独卡一个线程。

这就够了。

后面学网络编程和 Netty 时，再继续深挖会更自然。

---

十一、什么时候该优先用 NIO，什么时候老 IO 也完全够用

很多初学者学到 NIO 后，会出现另一个极端：

“以后是不是都该用 NIO，老 IO 过时了？”

也不是。

正确理解是：

NIO 更现代、更强大，但不是所有场景都必须上最重的那一套。

这些场景优先考虑 NIO

• 文件路径处理比较复杂
• 需要方便地复制、移动、遍历、过滤文件
• 要处理较大文件
• 对性能和资源占用更敏感
• 要做高并发网络编程
• 后续要接 Netty、Reactor、异步 IO 这条线

这些场景老 IO 也完全够用

• 简单的小文件读写练习
• 教学演示
• 逻辑非常短小的文本读写
• 你当前主要目标是先把字节流 / 字符流概念吃透

所以别把它理解成“新的一定替代旧的”。

更准确的说法是：

• 老 IO 帮你理解基础读写模型
• NIO 帮你进入更现代、更工程化的文件与网络处理方式

---

十二、学 NIO 时最容易踩的几个坑

这一节非常重要。

1）把 Path 继续当 String 用

如果你引入了 Path，却还是到处手写字符串拼接路径，那基本等于没真正用上它。

2）不理解 Buffer 的状态切换

尤其是：

• position
• limit
• capacity
• flip()
• clear()

这几个不清楚，ByteBuffer 基本就用不明白。

3）以为 NIO 天然就“更快”

NIO 的确为高性能提供了更好的可能性，但不是说只要代码换成 NIO，程序就自动起飞。

实际性能还取决于：

• 数据规模
• 访问模式
• 操作系统
• 磁盘性能
• 网络模型
• 代码是否合理使用缓冲和通道

4）在基础没打稳时，直接硬啃 Selector

如果你连流、缓冲区、文件读写、socket 基础都还没理顺，就直接上 Selector，很容易学得一团乱。

更稳的顺序永远是：

• 先打稳 IO 基础
• 再理解 Buffer / Channel
• 最后再进非阻塞网络编程

---

十三、给你一个更实用的学习顺序

如果你现在学到这里，我建议这样推进：

第一步：先会用 Path 和 Files 处理日常文件操作

先把这些写熟：

• 创建路径
• 判断存在
• 读取字符串
• 写入字符串
• 复制文件
• 移动文件
• 遍历目录

因为这部分最贴近日常开发。

第二步：再理解 Buffer 和 Channel

重点不是背方法名，而是搞清楚：

• 数据什么时候写进缓冲区
• 什么时候要 flip()
• 什么时候要清空缓冲区
• Channel 和 Buffer 是怎么配合的

第三步：最后再进网络 NIO

包括：

• SocketChannel
• ServerSocketChannel
• Selector
• 非阻塞 IO
• Reactor 模式

这样学，不容易乱，也更贴近真实工程能力成长路径。

---

十四、最后总结：NIO 解决的不是“语法问题”，而是“系统效率问题”

如果你只把 NIO 看成“Java 新出的另一套 IO API”，那会低估它。

它真正重要的地方是：

• 用 Path / Files 把文件系统操作变得更清晰
• 用 Buffer / Channel 提供更接近底层的数据处理方式
• 用 Selector 支撑高并发网络编程的核心模型

所以 NIO 这条线，本质上是在把 Java 从“会读写文件”推进到“更高效地处理系统资源”。

这也是为什么学完它之后，你对文件、网络、缓冲区、线程这些东西的理解，会明显比只停留在传统 IO 阶段更完整。