Java 中常见的输入输出(IO)操作，直接操作原始的字节流或字符流往往效率低下，尤其是处理大量数据时。Java IO体系中的缓冲流(Buffered Stream)通过引入缓冲区机制，显著提高了IO操作的性能。本文我将深入探讨Java缓冲流的原理、使用方法及性能优化技巧，帮你全面掌握这一重要技术。

一、缓冲流概述

1.1 什么是缓冲流

缓冲流是Java IO体系中用于装饰其他流的特殊流，它通过在内存中设置缓冲区，减少了直接与底层数据源(如磁盘、网络)的交互次数，从而提高了IO操作的效率。Java提供了四种缓冲流：

• BufferedInputStream：字节输入缓冲流
• BufferedOutputStream：字节输出缓冲流
• BufferedReader：字符输入缓冲流
• BufferedWriter：字符输出缓冲流

1.2 缓冲流的工作原理

缓冲流的核心是内部维护的一个缓冲区数组：

• 输入缓冲流：从数据源读取数据时，先将数据批量读入缓冲区，后续的读取操作直接从缓冲区获取数据，减少了与数据源的交互次数。
• 输出缓冲流：向目标写入数据时，先将数据写入缓冲区，当缓冲区满或调用flush()方法时，再将缓冲区中的数据批量写入目标，减少了与目标的交互次数。

1.3 缓冲流的优势

• 提高IO性能：减少了与底层数据源的交互次数
• 简化编程模型：提供了更方便的API，如BufferedReader的readLine()方法
• 支持mark和reset操作：某些缓冲流支持标记和重置操作，增强了灵活性

二、字节缓冲流详解

2.1 BufferedInputStream

BufferedInputStream为字节输入流提供缓冲功能，继承自FilterInputStream。

2.1.1 构造函数

• BufferedInputStream(InputStream in)：使用默认缓冲区大小(8192字节)创建缓冲流
• BufferedInputStream(InputStream in, int size)：使用指定大小的缓冲区创建缓冲流

2.1.2 核心方法

• int read()：从缓冲流读取一个字节
• int read(byte[] b, int off, int len)：从缓冲流读取字节到数组的指定位置
• void close()：关闭流并释放资源
• void mark(int readlimit)：标记当前位置
• void reset()：重置到最后标记的位置

2.1.3 使用示例

import java.io.*;public class BufferedInputStreamExample {public static void main(String[] args) {try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("large_file.dat"), 16384)) {byte[] buffer = new byte[4096];int bytesRead;while ((bytesRead = bis.read(buffer)) != -1) {// 处理读取的数据processData(buffer, bytesRead);}} catch (IOException e) {e.printStackTrace();}}private static void processData(byte[] buffer, int bytesRead) {// 数据处理逻辑}
}

2.2 BufferedOutputStream

BufferedOutputStream为字节输出流提供缓冲功能，继承自FilterOutputStream。

2.2.1 构造函数

• BufferedOutputStream(OutputStream out)：使用默认缓冲区大小(8192字节)创建缓冲流
• BufferedOutputStream(OutputStream out, int size)：使用指定大小的缓冲区创建缓冲流

2.2.2 核心方法

• void write(int b)：向缓冲流写入一个字节
• void write(byte[] b, int off, int len)：向缓冲流写入字节数组的指定部分
• void flush()：刷新缓冲区，将数据写入底层输出流
• void close()：关闭流，关闭前会先刷新缓冲区

2.2.3 使用示例

import java.io.*;public class BufferedOutputStreamExample {public static void main(String[] args) {try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("output.dat"), 16384)) {byte[] data = generateData(1024 * 1024); // 生成1MB数据// 写入数据到缓冲区bos.write(data);// 确保所有数据都写入底层流bos.flush();} catch (IOException e) {e.printStackTrace();}}private static byte[] generateData(int size) {byte[] data = new byte[size];// 填充数据for (int i = 0; i < size; i++) {data[i] = (byte) (i % 256);}return data;}
}

三、字符缓冲流详解

3.1 BufferedReader

BufferedReader为字符输入流提供缓冲功能，并提供了读取整行的便捷方法。

3.1.1 构造函数

• BufferedReader(Reader in)：使用默认缓冲区大小(8192字符)创建缓冲流
• BufferedReader(Reader in, int sz)：使用指定大小的缓冲区创建缓冲流

3.1.2 核心方法

• int read()：读取单个字符
• int read(char[] cbuf, int off, int len)：读取字符到数组的指定位置
• String readLine()：读取一行文本，以换行符结束
• void close()：关闭流并释放资源

3.1.3 使用示例

import java.io.*;public class BufferedReaderExample {public static void main(String[] args) {try (BufferedReader reader = new BufferedReader(new FileReader("large_text_file.txt"), 32768)) {String line;while ((line = reader.readLine()) != null) {// 处理每行文本processLine(line);}} catch (IOException e) {e.printStackTrace();}}private static void processLine(String line) {// 处理文本行的逻辑}
}

3.2 BufferedWriter

BufferedWriter为字符输出流提供缓冲功能，并提供了写入换行符的便捷方法。

3.2.1 构造函数

• BufferedWriter(Writer out)：使用默认缓冲区大小(8192字符)创建缓冲流
• BufferedWriter(Writer out, int sz)：使用指定大小的缓冲区创建缓冲流

3.2.2 核心方法

• void write(int c)：写入单个字符
• void write(char[] cbuf, int off, int len)：写入字符数组的指定部分
• void write(String s, int off, int len)：写入字符串的指定部分
• void newLine()：写入一个行分隔符
• void flush()：刷新缓冲区
• void close()：关闭流，关闭前会先刷新缓冲区

3.2.3 使用示例

import java.io.*;public class BufferedWriterExample {public static void main(String[] args) {try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"), 32768)) {for (int i = 0; i < 100000; i++) {writer.write("这是第" + i + "行文本");writer.newLine(); // 写入换行符}// 确保所有数据都写入文件writer.flush();} catch (IOException e) {e.printStackTrace();}}
}

四、缓冲流的性能优化

4.1 缓冲区大小选择

缓冲区大小对性能有显著影响，一般来说：

• 较大的缓冲区(如32KB或64KB)适合处理大文件或网络数据
• 较小的缓冲区(如4KB或8KB)适合处理小文件或频繁的IO操作
• 默认缓冲区大小(8KB)通常适用于大多数场景

性能测试示例：

import java.io.*;public class BufferSizePerformanceTest {private static final int FILE_SIZE = 1024 * 1024 * 100; // 100MBprivate static final String TEST_FILE = "test_file.dat";public static void main(String[] args) {generateTestFile();int[] bufferSizes = {4096, 8192, 16384, 32768, 65536};for (int size : bufferSizes) {testReadPerformance(size);}}private static void generateTestFile() {try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(TEST_FILE))) {byte[] buffer = new byte[1024];for (int i = 0; i < FILE_SIZE / 1024; i++) {bos.write(buffer);}} catch (IOException e) {e.printStackTrace();}}private static void testReadPerformance(int bufferSize) {long startTime = System.currentTimeMillis();try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(TEST_FILE), bufferSize)) {byte[] buffer = new byte[1024];while (bis.read(buffer) != -1) {// 读取但不处理数据}} catch (IOException e) {e.printStackTrace();}long endTime = System.currentTimeMillis();System.out.println("缓冲区大小: " + bufferSize + " 字节, 读取时间: " + (endTime - startTime) + " 毫秒");}
}

4.2 与其他流结合使用

缓冲流通常与其他流组合使用，形成功能强大的流管道：

示例：读取压缩文件中的文本

import java.io.*;
import java.util.zip.GZIPInputStream;public class CombinedStreamExample {public static void main(String[] args) {try (BufferedReader reader = new BufferedReader(new InputStreamReader(new GZIPInputStream(new FileInputStream("data.txt.gz"))))) {String line;while ((line = reader.readLine()) != null) {System.out.println(line);}} catch (IOException e) {e.printStackTrace();}}
}

4.3 批量读写操作

使用数组进行批量读写比单字节/字符读写效率更高：

高效写法：

try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("input.dat"))) {byte[] buffer = new byte[8192];int bytesRead;while ((bytesRead = bis.read(buffer)) != -1) {// 批量处理数据}
}

低效写法：

try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("input.dat"))) {int byteValue;while ((byteValue = bis.read()) != -1) {// 单字节处理数据}
}

五、缓冲流的最佳实践

5.1 使用try-with-resources语句

确保流资源被正确关闭，避免资源泄漏：

try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"));BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {String line;while ((line = reader.readLine()) != null) {writer.write(processLine(line));writer.newLine();}
} catch (IOException e) {e.printStackTrace();
}

5.2 合理选择缓冲区大小

根据实际应用场景选择合适的缓冲区大小，避免过大或过小：

// 处理大文件时使用较大的缓冲区
try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("large_file.dat"), 65536)) {// 处理数据
}

5.3 及时刷新缓冲区

在需要确保数据写入目标时，调用flush()方法：

try (BufferedWriter writer = new BufferedWriter(new FileWriter("log.txt"))) {// 写入重要日志writer.write("系统启动成功");writer.newLine();// 立即刷新，确保数据写入文件writer.flush();// 继续写入其他日志writer.write("开始处理数据");writer.newLine();
}

六、常见问题与解决方案

6.1 缓冲区未刷新导致数据丢失

如果在关闭流之前没有调用flush()方法，缓冲区中的数据可能不会被写入目标。使用try-with-resources语句可以避免这个问题，因为它会自动调用close()方法，而close()方法会先刷新缓冲区。

6.2 缓冲流与mark/reset操作

某些缓冲流支持mark和reset操作，但需要注意：

• 标记位置不能超过缓冲区大小
• 调用reset()后，只能读取到标记位置之后、缓冲区范围内的数据

示例：

try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("data.dat"))) {// 标记当前位置bis.mark(1024);// 读取一些数据byte[] buffer = new byte[512];bis.read(buffer);// 重置到标记位置bis.reset();// 可以再次读取之前的数据bis.read(buffer);
}

6.3 缓冲流性能问题

• 如果发现使用缓冲流后性能反而下降，可能是因为：
  • 缓冲区设置过小，导致频繁刷新
  • 每次只读写少量数据，没有充分利用缓冲区
  • 底层IO设备本身速度很快，缓冲带来的收益有限

若这篇内容帮到你，动动手指支持下！关注不迷路，干货持续输出！
ヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉ