跳到主要内容
约 12 分钟3 张卡

Java 流式 I/O

Java 流式 I/O 分两类:字节流读写原始字节,用于图片、压缩包这类二进制数据;字符流读写字符,用于文本。文件、Socket 在底层传的都是字节,字符流是在字节流之上,按某个字符集把字节解码成字符、把字符编码成字节。

选择流时,先判断要原样保留字节,还是要解释文本。用字符流复制图片可能破坏原始字节,读写两端字符集不一致则可能产生乱码。读写循环还要处理三个边界:一次 read 未必读满,缓冲只减少特定调用的成本,flush() 也不等于数据已经持久化。

1. 面试核心​

先记住这几条,再读正文
  • 字节流读写原始字节,适合二进制数据;字符流读写字符序列,适合文本,读写时都要明确字符集。卡 · 字节流
  • InputStreamReader 按指定字符集把字节解码为字符,OutputStreamWriter 反过来把字符编码为字节。
  • read(byte[]) 返回本次实际读到的字节数,可能少于数组长度,-1 才表示流结束;写出时只能写这么多。卡 · 部分读取
  • 缓冲流把多次小读写合并成大块操作,减少对底层流和操作系统的调用次数。
  • flush() 只是把 Java 缓冲区里的数据交给底层流,要保证落到磁盘,还需要 FileChannel.force 等机制。

2. 字节流​

字节流的两个基类是 InputStream 和 OutputStream,一个读字节,一个写字节,不对内容做任何解释。图片、压缩包、加密数据都必须原样保留每个字节,格式未知的文件也应该按字节处理。比如复制一张图片:

Path source = Path.of("avatar.png");
Path target = Path.of("avatar-copy.png");

try (
InputStream input = Files.newInputStream(source);
OutputStream output = Files.newOutputStream(target)
) {
input.transferTo(output);
}

transferTo 把输入流的字节原样搬到输出流,不解释内容。例如,0x41 在 UTF-8 文本里表示 A,在图片文件里却要按图片格式解释。字节流只保证搬运字节,具体含义由使用它的代码决定。

流打开后要关闭,否则会泄漏文件句柄。谁创建流(或明确接管了流),就由谁关闭,优先用 try-with-resources。关闭顺序和异常处理见 Java 异常。

2.1 部分读取​

read(byte[]) 的返回值表示本次实际读到的字节数,不保证等于数组长度。数组非空时,读取会等待数据、流结束或异常;成功读取可能只填满数组的一部分,返回 -1 才表示流结束。读写循环因此要用返回值确定有效范围:

byte[] buffer = new byte[8192];
int count;

while ((count = input.read(buffer)) != -1) {
output.write(buffer, 0, count);
}

假设这一轮只读到 100 个字节,count 就是 100,只有 buffer[0] 到 buffer[99] 是本轮的数据。write(buffer, 0, count) 恰好写出这部分;若调用 output.write(buffer),会把整个 8192 字节数组写出,未被本轮覆盖的旧内容也会混进结果。

读协议里固定长度的字段时,比如一个 4 字节的长度头,可以用 DataInputStream.readFully。它会一直读到填满指定长度为止,中途遇到流末尾就抛出 EOFException。

还有一个容易误用的方法是 available(),它返回的是「现在不阻塞就能读到的字节数」的估计值,不是流的总长度,也不能用来判断一条网络消息是否已经收全。消息到哪结束,要靠协议里的长度字段或结束标记。

3. 字符流​

字符流的两个基类是 Reader 和 Writer,读写的单位是字符。字符和字节之间怎样对应,由字符集决定,比如 UTF-8 里「欢」是三个字节 E6 AC A2。读取时把字节转换为字符叫解码,写入时把字符转换为字节叫编码。

下面的读取和写入都明确指定了 UTF-8:

Path path = Path.of("article.md");

try (BufferedReader reader = Files.newBufferedReader(path, StandardCharsets.UTF_8)) {
String firstLine = reader.readLine();
System.out.println(firstLine);
}

try (BufferedWriter writer = Files.newBufferedWriter(path, StandardCharsets.UTF_8)) {
writer.write("欢迎来到 Coding 101");
writer.newLine();
}

第一段读取并打印首行;第二段重新打开同一路径写入,会覆盖原文件,再写入文本和换行符。这是两个读写用法的示例,并不是保留原文件内容的更新操作。

读写双方的字符集需要一致。例如,按 UTF-8 写入的「欢」若用 GBK 解码,就无法按原来的规则还原字符,可能出现乱码或解码错误。所以协议和文件格式应明确约定字符集。

3.1 InputStreamReader 与 OutputStreamWriter​

手里已经有一个字节流,比如 Socket 的输入输出流,又想按文本处理时,就用转换流把它包成字符流。InputStreamReader 负责解码,OutputStreamWriter 负责编码:

Reader reader = new InputStreamReader(
socket.getInputStream(),
StandardCharsets.UTF_8
);

Writer writer = new OutputStreamWriter(
socket.getOutputStream(),
StandardCharsets.UTF_8
);

reader 把 Socket 收到的 UTF-8 字节解码成字符,writer 把写入的字符编码成 UTF-8 字节,再交给 Socket。注意 Reader 只交出解码后的字符,不保留原始字节;字符要重新变回字节,必须再选一次目标字符集。

3.2 char 与用户可见字符​

字符流读出来的 char 是一个 UTF-16 代码单元,也就是一个 16 位的编码值,并不总等于用户看到的一个字符。比如 emoji「😀」要用两个 char(一个代理对)表示。所以按字符计数或截断文本时,不能直接数 char 的个数。

码点、代理对和组合字符的区别见 String。

4. 缓冲流​

缓冲流在内存里放一块缓冲区,把很多次小读写合并成少数几次大块读写。没有缓冲时,每次 read() 读一个字节,FileInputStream 就要发起一次系统调用;读一个 1 MB 的文件就是约一百万次。加了缓冲以后,读取时一次从底层读一大块(BufferedInputStream 默认 8192 字节),后续的小读取直接从内存里拿;写入时先在内存里攒着,攒满了再一次交给底层流:

try (
InputStream input = new BufferedInputStream(Files.newInputStream(source));
OutputStream output = new BufferedOutputStream(Files.newOutputStream(target))
) {
input.transferTo(output);
}

这里用包装的方式给输入和输出都加了缓冲。字符流的 BufferedReader、BufferedWriter 是同样的思路,还额外提供了 readLine()、newLine() 这类按行处理的方法。

如果代码已经按大块读写,再包装缓冲流未必能进一步减少底层调用。transferTo 和 Files.copy 的具体路径还取决于流实现与平台,不能只凭「多包一层」判断更快。应先看原来的读写粒度,再测量是否需要缓冲。

4.1 缓冲区大小​

增大缓冲区可能减少底层调用,也会增加每个流占用的内存。并发连接多时,单个缓冲区的小幅增长也会累积:每个连接多用 64 KB,一万个连接就多用约 640 MB。调用次数能否继续减少,还取决于每次实际读写多少数据。

所以先用默认大小。性能分析确认小粒度 I/O 是瓶颈之后,再结合数据量、并发连接数和延迟要求调整。

5. 装饰器组合​

装饰器模式是在保留原接口的前提下,用包装对象增加能力。BufferedInputStream 包装一个 InputStream,对调用方仍是 InputStream,但增加了缓冲。转换流则负责衔接字节与字符这两种接口。把它们组合起来,就能完成缓冲、解压、解码和按行读取:

try (
InputStream file = Files.newInputStream(Path.of("data.gz"));
InputStream buffered = new BufferedInputStream(file);
InputStream decompressed = new GZIPInputStream(buffered);
Reader decoded = new InputStreamReader(decompressed, StandardCharsets.UTF_8);
BufferedReader lines = new BufferedReader(decoded)
) {
lines.lines().forEach(System.out::println);
}

读取时,调用从外层向内层请求数据,数据处理结果再逐层向外返回:file 提供压缩字节,buffered 缓冲这些字节,decompressed 解压出 UTF-8 字节,decoded 解码为字符,最后由 lines 按行交给调用方。每层的输入输出类型必须与相邻层对应。

还原数据时,要反过来撤销写入时的转换。这个文件先将文本编码成 UTF-8 字节、再压缩,读取就要先解压、再解码。若直接解码压缩字节,得到的不会是原文,还可能发生解码错误。

关闭也要注意。这些包装类关闭时会顺带关闭被包装的流,所以只关最外层也能释放文件。本例把每一层都声明成资源,好处是如果某一层的构造方法抛出异常(比如文件不是合法的 gzip 格式,GZIPInputStream 构造时就会报错),已经打开的内层流仍会被关闭。换用其他包装类时,要看它的文档,确认关闭时会不会关闭底层流。

6. flush 与持久化​

flush() 要求输出流把已缓冲的数据交给下层。使用输出缓冲时,write 返回并不代表数据已经离开 Java 缓冲区;需要及时提交这一批数据时,可以显式刷新:

writer.write("event\n");
writer.flush();

写完事件后刷新,可以避免它继续滞留在 Java 缓冲区,但不保证对方立即收到或处理完。连接可以保持打开,下一条消息继续写入。BufferedWriter.close() 也会尝试刷新缓冲内容;关闭过程若发生 I/O 错误,仍需处理异常。没有刷新或关闭就异常退出,尚在 Java 缓冲区中的数据可能丢失。

flush() 不提供磁盘持久化保证。写文件时,数据可能只是进入操作系统的页缓存,尚未写到存储设备。需要崩溃后仍能恢复数据时,要使用 FileChannel.force 等写回机制,并确认文件系统和硬件提供的保证。

映射文件的写回范围见 零拷贝。

每次刷新都会提前结束当前这一批,刷得越勤,缓冲省下的调用就越少。什么时候刷新,应该由消息边界、交互延迟要求或持久化协议决定,而不是每写一次就刷一次。

7. API 选择​

选 API 先看数据是文本还是二进制,再看读写方式:

  1. 二进制数据:使用 InputStream、OutputStream 或字节 Channel。
  2. 文本数据:使用 Reader、Writer 或 Files 的带字符集方法。
  3. 大量小读写:使用缓冲或显式块读取。
  4. 一次性文件复制:优先查看 Files.copy、InputStream.transferTo 或 FileChannel.transferTo。
  5. 随机访问、内存映射或多路复用:进入 NIO 的 Channel、Buffer 和 Selector 模型。

二进制文件必须按字节复制,因为解码再编码未必能还原原始字节。例如,图片中出现了不合法的 UTF-8 字节序列,而解码器采用替换策略时,会生成替换字符 U+FFFD;重新编码成 UTF-8 后,得到的是 EF BF BD,原始字节已经丢失。采用报错策略则会中断读取,同样无法完成原样复制。

8. 跨块解码与错误处理​

分块读取文本时,解码状态必须跨读取保留,因为字节块的边界未必是字符的边界。例如,「欢」在 UTF-8 中是三个字节 E6 AC A2。一次 read 只得到 E6 AC 时,单独用 new String(bytes, UTF_8) 解码,会把残缺序列替换掉;下一块开头的 A2 也无法独立还原这个字。

InputStreamReader 会保留还没有拼完整的字节,等后续读取补齐后再解码。因此它能处理跨块字符,不要求每次 read 都恰好停在字符末尾。

输入本身损坏时,处理方式取决于所用 API 和错误策略。new String(byte[], Charset) 会替换错误输入,而新建的 CharsetDecoder 默认采用 REPORT,报告错误。下面显式写出两类错误的策略:格式错误(malformed)和无法映射(unmappable)都拒绝继续解码。

CharsetDecoder decoder = StandardCharsets.UTF_8.newDecoder()
.onMalformedInput(CodingErrorAction.REPORT)
.onUnmappableCharacter(CodingErrorAction.REPORT);
try (Reader reader = new InputStreamReader(input, decoder)) {
char[] chars = new char[1024];
int count;
while ((count = reader.read(chars)) != -1) {
consume(chars, 0, count); // 只处理本次字符;格式损坏时读取抛异常。
}
}

和字节读取一样,这里也只把本次读到的 count 个字符交给 consume。遇到损坏的文本,read 会抛出 MalformedInputException(IOException 的子类),调用方就能拒绝这份输入,而不是带着替换字符继续处理。

默认字符集还受 JDK 版本和运行环境影响。Java 17 的默认值取决于操作系统和区域设置;Java 21 默认使用 UTF-8,但可以通过 -Dfile.encoding=COMPAT 采用兼容旧环境的选择方式。API 若使用平台默认字符集,同一份代码换环境后就可能得到不同结果,所以协议和文件格式应显式指定字符集。

9. 常见问题​

9.1 字符流一定比字节流快吗?​

不一定,字符流在字节流的基础上还多了编解码这一步。实际快慢取决于字符集、缓冲方式、数据量和底层设备。选择时先看数据是不是文本,性能问题再按实际读写方式测量。

9.2 为什么 InputStream.read() 返回 int?​

9.3 readLine() 会保留换行符吗?​

9.4 什么时候可以使用默认字符集?​

10. 面试题卡片​

11. 参考资料​

来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明