Java BufferedWriter

在 Java 中处理文本输出时，效率是一个重要考量因素。虽然可以使用基本的 Writer 类直接写入字符数据，但对于频繁的写操作，这种方式可能会导致性能下降。这就是 BufferedWriter 发挥作用的地方。

什么是 BufferedWriter？

BufferedWriter 是 Java IO 包中的一个类，它为其他 Writer 提供缓冲功能，显著提高写入效率。它通过将数据先写入内存缓冲区，然后一次性写入目标媒介（如文件），减少了实际的 I/O 操作次数。

BufferedWriter 的主要特点

效率高：减少了物理 I/O 操作，提高写入性能
提供缓冲：内部维护一个字符缓冲区
换行方法：提供了平台无关的 newLine() 方法
可指定缓冲区大小：允许开发者根据需求调整缓冲区大小

创建 BufferedWriter

要创建一个 BufferedWriter 对象，你需要首先创建一个基础的 Writer 对象（如 FileWriter），然后将其包装在 BufferedWriter 中：

java
// 创建基本的 BufferedWriter
try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
    // 使用 writer 进行写操作
} catch (IOException e) {
    e.printStackTrace();
}

// 指定缓冲区大小的 BufferedWriter
try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"), 8192)) {
    // 使用 writer 进行写操作
} catch (IOException e) {
    e.printStackTrace();
}

BufferedWriter 的常用方法

写入方法

BufferedWriter 提供了多种写入数据的方法：

java
try (BufferedWriter writer = new BufferedWriter(new FileWriter("example.txt"))) {
    // 写入单个字符
    writer.write('A');
    
    // 写入字符串
    writer.write("Hello, Java IO!");
    
    // 写入字符串的一部分
    writer.write("BufferedWriter", 0, 8); // 只写入 "Buffered"
    
    // 写入字符数组
    char[] charArray = {'J', 'a', 'v', 'a'};
    writer.write(charArray);
    
    // 写入字符数组的一部分
    writer.write(charArray, 1, 3); // 写入 "ava"
} catch (IOException e) {
    e.printStackTrace();
}

newLine() 方法

newLine() 是 BufferedWriter 特有的方法，用于写入与平台相关的行分隔符：

java
try (BufferedWriter writer = new BufferedWriter(new FileWriter("lines.txt"))) {
    writer.write("第一行");
    writer.newLine();  // 插入换行符
    writer.write("第二行");
    writer.newLine();
    writer.write("第三行");
} catch (IOException e) {
    e.printStackTrace();
}

输出 (lines.txt):

第一行
第二行
第三行

提示

使用 newLine() 方法比直接写入 \n 更好，因为它会根据不同操作系统自动使用正确的换行符（Windows: \r\n, Unix/Linux: \n, Mac: \r）。

flush() 方法

flush() 方法强制将缓冲区的内容写入目标媒介：

java
try (BufferedWriter writer = new BufferedWriter(new FileWriter("flush-demo.txt"))) {
    writer.write("这是一些文本");
    // 此时文本仍在缓冲区中，尚未写入文件
    
    writer.flush();
    // 现在文本已被写入文件
    
    writer.write("更多文本");
    // 在方法结束时，try-with-resources 会自动调用 close()，
    // 这也会刷新缓冲区
} catch (IOException e) {
    e.printStackTrace();
}

实际应用场景

场景1：写入大量数据

当需要写入大量文本数据时，使用 BufferedWriter 可以显著提高性能：

java
public static void writeLotsOfData() {
    long startTime = System.currentTimeMillis();
    
    try (BufferedWriter writer = new BufferedWriter(new FileWriter("large-data.txt"))) {
        for (int i = 0; i < 1000000; i++) {
            writer.write("这是第 " + i + " 行数据\n");
            
            // 每写入 10000 行刷新一次，平衡内存使用和写入频率
            if (i % 10000 == 0) {
                writer.flush();
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    
    long endTime = System.currentTimeMillis();
    System.out.println("写入耗时: " + (endTime - startTime) + " 毫秒");
}

如果用普通的 FileWriter 执行相同操作，速度会慢很多。

场景2：日志记录器实现

一个简单的日志记录器实现：

java
public class SimpleLogger {
    private BufferedWriter logWriter;
    
    public SimpleLogger(String logFile) throws IOException {
        // 追加模式打开文件
        logWriter = new BufferedWriter(new FileWriter(logFile, true));
    }
    
    public void log(String level, String message) throws IOException {
        String timestamp = new java.util.Date().toString();
        logWriter.write(timestamp + " [" + level + "] " + message);
        logWriter.newLine();
        // 日志信息应该立即写入文件
        logWriter.flush();
    }
    
    public void close() throws IOException {
        if (logWriter != null) {
            logWriter.close();
        }
    }
    
    // 使用示例
    public static void main(String[] args) {
        try {
            SimpleLogger logger = new SimpleLogger("application.log");
            logger.log("INFO", "应用程序启动");
            // 执行一些操作
            logger.log("DEBUG", "正在处理数据...");
            // 更多操作
            logger.log("INFO", "应用程序关闭");
            logger.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出 (application.log):

Wed Oct 25 15:30:10 CST 2023 [INFO] 应用程序启动
Wed Oct 25 15:30:10 CST 2023 [DEBUG] 正在处理数据...
Wed Oct 25 15:30:10 CST 2023 [INFO] 应用程序关闭

场景3：CSV 文件生成器

使用 BufferedWriter 创建 CSV 文件：

java
public class CSVGenerator {
    public static void generateUserReport(List<User> users, String fileName) throws IOException {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(fileName))) {
            // 写入标题行
            writer.write("ID,姓名,年龄,邮箱");
            writer.newLine();
            
            // 写入数据行
            for (User user : users) {
                writer.write(String.format("%d,%s,%d,%s", 
                    user.getId(),
                    user.getName(),
                    user.getAge(),
                    user.getEmail()));
                writer.newLine();
            }
        }
    }
    
    // User 类示例
    static class User {
        private int id;
        private String name;
        private int age;
        private String email;
        
        // 构造函数、getter 和 setter 略
        
        public int getId() { return id; }
        public String getName() { return name; }
        public int getAge() { return age; }
        public String getEmail() { return email; }
    }
}

BufferedWriter vs FileWriter

为什么要使用 BufferedWriter 而不是直接使用 FileWriter？下面是一个性能比较：

java
public static void compareWritePerformance() throws IOException {
    int iterations = 100000;
    
    // 使用 FileWriter
    long start = System.currentTimeMillis();
    try (FileWriter fw = new FileWriter("file-writer.txt")) {
        for (int i = 0; i < iterations; i++) {
            fw.write("测试数据行 " + i + "\n");
        }
    }
    long fileWriterTime = System.currentTimeMillis() - start;
    
    // 使用 BufferedWriter
    start = System.currentTimeMillis();
    try (BufferedWriter bw = new BufferedWriter(new FileWriter("buffered-writer.txt"))) {
        for (int i = 0; i < iterations; i++) {
            bw.write("测试数据行 " + i + "\n");
        }
    }
    long bufferedWriterTime = System.currentTimeMillis() - start;
    
    System.out.println("FileWriter 耗时: " + fileWriterTime + " ms");
    System.out.println("BufferedWriter 耗时: " + bufferedWriterTime + " ms");
    System.out.println("性能提升: " + 
        String.format("%.2f", (double)fileWriterTime / bufferedWriterTime) + " 倍");
}

输出示例：

FileWriter 耗时: 1250 ms
BufferedWriter 耗时: 320 ms
性能提升: 3.91 倍

警告

性能差异可能因系统配置、硬盘速度和其他因素而不同，但 BufferedWriter 通常会显著快于直接使用 FileWriter。

使用 BufferedWriter 的最佳实践

始终使用 try-with-resources 语句：确保资源被正确关闭

java
try (BufferedWriter writer = new BufferedWriter(new FileWriter("file.txt"))) {
    // 使用 writer
}

根据需要调整缓冲区大小：默认缓冲区通常足够，但对于特定场景可能需要调整

java
// 对于大量数据，可以使用较大的缓冲区
BufferedWriter writer = new BufferedWriter(new FileWriter("file.txt"), 32768);

适时调用 flush()：在关键节点刷新缓冲区，特别是在写入重要数据后
java
```
writer.write("重要交易数据");
writer.flush();  // 确保写入到磁盘
```

使用 newLine() 而不是 \n：保持跨平台一致性

java
writer.write("第一行");
writer.newLine();  // 比 writer.write("\n") 更好

捕获并处理 IOException：所有 I/O 操作都可能抛出异常

java
try {
    // 写入操作
} catch (IOException e) {
    System.err.println("写入失败: " + e.getMessage());
    // 适当的错误处理
}

总结

BufferedWriter 是 Java 中高效写入文本数据的关键工具。通过提供缓冲功能，它显著减少了 I/O 操作次数，提高了应用程序性能。主要优势包括：

通过缓冲减少 I/O 调用，提高写入效率
提供平台无关的换行方法
允许自定义缓冲区大小以优化性能

在处理文本输出时，特别是涉及大量数据或频繁写入操作的场景，BufferedWriter 应该是你的首选。

练习

创建一个程序，使用 BufferedWriter 生成一个包含 1 到 100 数字的文本文件，每行一个数字。
编写一个简单的文件复制工具，从一个文件读取内容，然后使用 BufferedWriter 写入另一个文件。
改进上面的日志记录器，添加不同的日志级别（如 DEBUG, INFO, WARNING, ERROR）和日志轮换功能。
创建一个程序，生成一个大型 CSV 文件，包含随机生成的用户数据（ID、姓名、年龄、邮箱等）。
比较不同缓冲区大小（如 1024、4096、16384 字节）对写入性能的影响。

进一步阅读

Java BufferedWriter 官方文档
Java IO 流的其他类，如 BufferedReader、PrintWriter 和 FileWriter
Java NIO（New I/O）包，提供了更现代的 I/O API

通过掌握 BufferedWriter，你已经迈出了高效 Java I/O 处理的重要一步！

什么是 BufferedWriter？​

BufferedWriter 的主要特点​

创建 BufferedWriter​

BufferedWriter 的常用方法​

写入方法​

newLine() 方法​

flush() 方法​

实际应用场景​

场景1：写入大量数据​

场景2：日志记录器实现​

场景3：CSV 文件生成器​

BufferedWriter vs FileWriter​

使用 BufferedWriter 的最佳实践​

总结​

练习​

进一步阅读​