// 默認緩衝區大小（8192字節 = 8KB）
BufferedInputStream(InputStream in)
BufferedOutputStream(OutputStream out)

// 自定義緩衝區大小
BufferedInputStream(InputStream in, int size)
BufferedOutputStream(OutputStream out, int size)

public class BufferedStreamDemo {
    public static void main(String[] args) {
        // 源文件和目標文件路徑
        String srcPath = "test.jpg";
        String destPath = "test_copy.jpg";
        
        // try-with-resources：自動關閉流（先關緩衝流，再關底層流）
        try (
            // 包裝底層流
            InputStream in = new FileInputStream(srcPath);
            BufferedInputStream bis = new BufferedInputStream(in);  // 字節緩衝輸入流
            
            OutputStream out = new FileOutputStream(destPath);
            BufferedOutputStream bos = new BufferedOutputStream(out);  // 字節緩衝輸出流
        ) {
            byte[] buffer = new byte[1024];  // 臨時存儲讀取的數據
            int len;
            // 讀取數據（從緩衝區讀，而非直接讀磁盤）
            while ((len = bis.read(buffer)) != -1) {
                // 寫入數據（先寫入緩衝區，滿了自動刷到磁盤）
                bos.write(buffer, 0, len);
            }
            // 手動刷新（確保緩衝區剩餘數據寫入磁盤，close()也會自動刷新）
            bos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// BufferedInputStream 核心字段
protected byte[] buf;  // 緩衝區數組
protected int count;   // 緩衝區中有效數據的末尾索引
protected int pos;     // 當前讀取位置

public int read() throws IOException {
    // 若緩衝區無數據，從底層流填充緩衝區
    if (pos >= count) {
        fill();  // 關鍵：填充緩衝區
        if (pos >= count) return -1;  // 已到流末尾
    }
    // 從緩衝區讀取1字節（內存操作，極快）
    return buf[pos++] & 0xff;
}

// 填充緩衝區
private void fill() throws IOException {
    // ... 省略校驗邏輯 ...
    // 從底層流讀取數據到緩衝區（一次讀滿buf，減少IO次數）
    int n = getInIfOpen().read(buf, 0, buf.length);
    if (n > 0) count = n;  // 更新有效數據長度
}

public class BufferedCharStreamDemo {
    public static void main(String[] args) {
        String srcPath = "source.txt";
        String destPath = "dest.txt";
        
        try (
            // 包裝字符流（注意：字符流需指定編碼，默認用系統編碼可能有亂碼）
            Reader reader = new FileReader(srcPath, StandardCharsets.UTF_8);
            BufferedReader br = new BufferedReader(reader);
            
            Writer writer = new FileWriter(destPath, StandardCharsets.UTF_8);
            BufferedWriter bw = new BufferedWriter(writer);
        ) {
            String line;
            // 一行一行讀（BufferedReader的核心優勢）
            while ((line = br.readLine()) != null) {
                // 寫入一行
                bw.write(line);
                // 寫入換行（跨平台兼容）
                bw.newLine();
            }
            bw.flush();  // 確保數據寫入
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class PerformanceTest {
    private static final String SRC = "large_video.mp4";
    private static final String DEST1 = "copy1.mp4";  // 普通字節流
    private static final String DEST2 = "copy2.mp4";  // 默認緩衝流（8KB）
    private static final String DEST3 = "copy3.mp4";  // 自定義緩衝流（64KB）

    public static void main(String[] args) {
        // 普通流
        long time1 = testCopy(new FileInputStream(SRC), new FileOutputStream(DEST1), false);
        // 默認緩衝流
        long time2 = testCopy(new BufferedInputStream(new FileInputStream(SRC)), 
                             new BufferedOutputStream(new FileOutputStream(DEST2)), true);
        // 自定義緩衝流（64KB）
        long time3 = testCopy(new BufferedInputStream(new FileInputStream(SRC), 64 * 1024), 
                             new BufferedOutputStream(new FileOutputStream(DEST3), 64 * 1024), true);

        System.out.println("普通流耗時：" + time1 + "ms");
        System.out.println("默認緩衝流耗時：" + time2 + "ms");
        System.out.println("64KB緩衝流耗時：" + time3 + "ms");
    }

    private static long testCopy(InputStream in, OutputStream out, boolean isBuffered) {
        long start = System.currentTimeMillis();
        try (in; out) {  // try-with-resources自動關閉
            byte[] buf = new byte[1024];
            int len;
            while ((len = in.read(buf)) != -1) {
                out.write(buf, 0, len);
            }
            if (isBuffered) {
                ((BufferedOutputStream) out).flush();  // 緩衝流手動刷新
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return System.currentTimeMillis() - start;
    }
}

// 正確：只關緩衝流
try (
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.txt"))
) {
    // ... 操作 ...
}

// 正確：指定編碼
Reader reader = new FileReader("a.txt", StandardCharsets.UTF_8);
// 錯誤：依賴系統編碼（可能亂碼）
Reader reader = new FileReader("a.txt");