如何读取BufferedWriter对象中的字符串并统计特定字符数量？

BufferedWriter是Java中的只写字符流，本身没有提供读取内部缓存或已写入内容的API，所以直接从传入的BufferedWriter对象中读取内容是不可能的。要实现统计已写入内容中*的数量，需要通过包装/装饰器模式来追踪所有写入操作。

解决方案：自定义可追踪的BufferedWriter包装类 #

创建一个继承自BufferedWriter的子类，在每次写入操作时同步记录内容，这样就能随时获取已写入的完整字符串并进行统计。

步骤1：实现TrackableBufferedWriter类 #

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.Writer;

public class TrackableBufferedWriter extends BufferedWriter {
    private final StringBuilder contentTracker = new StringBuilder();

    public TrackableBufferedWriter(Writer out) {
        super(out);
    }

    // 重写所有write方法，确保写入内容被追踪
    @Override
    public void write(String str) throws IOException {
        contentTracker.append(str);
        super.write(str);
    }

    @Override
    public void write(String str, int off, int len) throws IOException {
        contentTracker.append(str, off, len);
        super.write(str, off, len);
    }

    @Override
    public void write(int c) throws IOException {
        contentTracker.append((char) c);
        super.write(c);
    }

    @Override
    public void write(char[] cbuf, int off, int len) throws IOException {
        contentTracker.append(cbuf, off, len);
        super.write(cbuf, off, len);
    }

    // 获取已写入的完整内容
    public String getTrackedContent() {
        return contentTracker.toString();
    }
}

步骤2：使用包装类统计*数量 #

在调用writeValue方法前，将原始BufferedWriter包装为TrackableBufferedWriter，然后在方法内通过包装类获取内容并统计：

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class Demo {
    public static int writeValue(TrackableBufferedWriter writer) throws IOException {
        writer.write("Here is one *");
        writer.write("Here is two *");
        
        // 统计内容中的*数量
        String content = writer.getTrackedContent();
        long starCount = content.chars().filter(c -> c == '*').count();
        return (int) starCount;
    }

    public static void main(String[] args) throws IOException {
        // 原始的BufferedWriter（比如写入文件）
        BufferedWriter originalWriter = new BufferedWriter(new FileWriter("output.txt"));
        // 包装为可追踪的Writer
        TrackableBufferedWriter trackableWriter = new TrackableBufferedWriter(originalWriter);
        
        int count = writeValue(trackableWriter);
        System.out.println("*的数量：" + count); // 输出2
        
        // 记得关闭流
        trackableWriter.close();
    }
}

测试场景简化方案 #

如果只是在测试时需要统计，不需要真正写入到目标流（比如文件），可以直接使用StringWriter配合BufferedWriter：

import java.io.BufferedWriter;
import java.io.StringWriter;
import java.io.IOException;

public class TestDemo {
    public static void main(String[] args) throws IOException {
        StringWriter stringWriter = new StringWriter();
        BufferedWriter writer = new BufferedWriter(stringWriter);
        
        writer.write("Here is one *");
        writer.write("Here is two *");
        writer.flush(); // 确保BufferedWriter缓存内容写入StringWriter
        
        String content = stringWriter.toString();
        long starCount = content.chars().filter(c -> c == '*').count();
        System.out.println("*的数量：" + (int) starCount); // 输出2
    }
}

注意事项 #

• 生产环境中必须使用包装类方案，确保所有写入操作都被追踪，同时不影响原流的写入功能。
• 务必重写所有write方法，避免遗漏单个字符、字符数组等写入场景导致内容追踪不全。
• 调用flush()或close()方法时，BufferedWriter会将内部缓存的内容写入目标流，包装类的追踪内容不受影响，因为所有写入操作已经同步记录。

内容的提问来源于stack exchange，提问作者Kabiraj Kharel