传统IO

// === 字节流 ===
 
// InputStream 核心方法
public abstract int read() throws IOException;          // 读取单个字节，返回 0~255，到末尾返回 -1
public int read(byte[] b) throws IOException;           // 读取多个字节到数组，返回实际读取的字节数
public void close() throws IOException;                 // 关闭流，释放资源
 
// OutputStream 核心方法
public abstract void write(int b) throws IOException;   // 写出单个字节（取 int 的低 8 位）
public void write(byte[] b) throws IOException;         // 写出整个字节数组
public void flush() throws IOException;                 // 刷新缓冲区，强制将数据写出
public void close() throws IOException;                 // 关闭流（关闭前会自动 flush）
 
// === 字符流 ===
 
// Reader 核心方法
public int read() throws IOException;                   // 读取单个字符，返回 0~65535，到末尾返回 -1
public int read(char[] cbuf) throws IOException;        // 读取多个字符到数组
public void close() throws IOException;                 // 关闭流
 
// Writer 核心方法
public void write(int c) throws IOException;            // 写出单个字符
public void write(char[] cbuf) throws IOException;      // 写出字符数组
public void write(String str) throws IOException;       // 直接写出字符串（字符流独有的便利方法）
public void flush() throws IOException;                 // 刷新缓冲区
public void close() throws IOException;                 // 关闭流

// 一层一层地"套娃"：
// 最内层：FileInputStream 负责从文件读取原始字节
// 中间层：InputStreamReader 负责将字节按 UTF-8 编码解码为字符
// 最外层：BufferedReader 负责提供缓冲和 readLine() 便利方法
BufferedReader reader = new BufferedReader(          // 第三层：缓冲 + readLine
    new InputStreamReader(                           // 第二层：字节 → 字符（指定编码）
        new FileInputStream("data.txt"),             // 第一层：从文件读字节
        "UTF-8"                                      // 指定字符编码
    )
);

// ┌─────────────────────────────────────────────────┐
// │            BufferedReader (处理流)                │
// │  功能: 缓冲 + readLine()                         │
// │  ┌─────────────────────────────────────────┐    │
// │  │      InputStreamReader (处理流/桥梁)      │    │
// │  │  功能: byte → char (UTF-8 解码)          │    │
// │  │  ┌─────────────────────────────────┐    │    │
// │  │  │   FileInputStream (节点流)       │    │    │
// │  │  │   功能: 从磁盘文件读取原始字节     │    │    │
// │  │  │   数据源: data.txt               │    │    │
// │  │  └─────────────────────────────────┘    │    │
// │  └─────────────────────────────────────────┘    │
// └─────────────────────────────────────────────────┘
//
// 数据流向: 磁盘文件 ──bytes──▶ FileInputStream
//                     ──bytes──▶ InputStreamReader (解码)
//                     ──chars──▶ BufferedReader (缓冲)
//                     ──String──▶ 你的程序

import java.io.*;
 
public class StreamComparison {
    public static void main(String[] args) throws IOException {
        String text = "你好Java";  // 包含中文的文本
 
        // ========== 字节流写入 ==========
        // FileOutputStream 逐字节写入，需要手动将字符串转为字节数组
        // 必须显式指定编码，否则依赖平台默认编码（不可靠）
        try (FileOutputStream fos = new FileOutputStream("byte_out.txt")) {
            byte[] bytes = text.getBytes("UTF-8");  // 手动编码：字符串 → UTF-8 字节数组
            fos.write(bytes);                        // 写出原始字节
            // "你" 在 UTF-8 中占 3 字节，"好" 占 3 字节
            // "J","a","v","a" 各占 1 字节
            // 总共写出 3 + 3 + 4 = 10 个字节
        }
 
        // ========== 字符流写入 ==========
        // FileWriter 直接写字符串，编码转换在内部自动完成
        // Java 11+ 可以在构造器中指定 Charset
        try (FileWriter fw = new FileWriter("char_out.txt")) {
            fw.write(text);  // 直接写字符串，无需手动转换
            // 内部自动按平台默认编码将字符转为字节写入文件
        }
 
        // ========== 字节流读取 ==========
        try (FileInputStream fis = new FileInputStream("byte_out.txt")) {
            byte[] buffer = new byte[1024];          // 准备一个字节缓冲区
            int bytesRead = fis.read(buffer);        // 读取字节到缓冲区
            // 手动解码：字节数组 → 字符串，必须指定与写入时相同的编码
            String result = new String(buffer, 0, bytesRead, "UTF-8");
            System.out.println("字节流读取: " + result);  // 输出: 你好Java
        }
 
        // ========== 字符流读取 ==========
        try (FileReader fr = new FileReader("char_out.txt")) {
            char[] buffer = new char[1024];          // 准备一个字符缓冲区
            int charsRead = fr.read(buffer);         // 读取字符到缓冲区
            String result = new String(buffer, 0, charsRead);  // 字符数组直接构造字符串
            System.out.println("字符流读取: " + result);  // 输出: 你好Java
        }
    }
}

// ✅ 推荐写法：try-with-resources（Java 7+）
// 实现了 AutoCloseable 接口的资源会在 try 块结束后自动关闭
// 即使发生异常也能保证资源被正确释放
try (
    FileInputStream fis = new FileInputStream("input.txt");    // 资源1
    FileOutputStream fos = new FileOutputStream("output.txt")  // 资源2
) {
    // 使用流进行读写操作
    byte[] buffer = new byte[1024];
    int len;
    while ((len = fis.read(buffer)) != -1) {  // 循环读取直到流末尾
        fos.write(buffer, 0, len);             // 将读到的数据写出
    }
}  // 自动调用 fos.close() 和 fis.close()，关闭顺序与声明顺序相反
 
// ❌ 不推荐的老写法：手动 try-finally
// 代码冗长，且多个 close() 的异常处理容易写错
FileInputStream fis = null;
try {
    fis = new FileInputStream("input.txt");
    // ... 使用流
} finally {
    if (fis != null) {
        try {
            fis.close();  // 手动关闭，还要处理 close 本身可能抛出的异常
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// 这三个是 System 类中的静态字段
public static final InputStream in;   // 标准输入流（默认关联键盘）
public static final PrintStream out;  // 标准输出流（默认关联控制台）
public static final PrintStream err;  // 标准错误流（默认关联控制台，但可独立重定向）

// Scanner 内部包装了 System.in，提供了类型解析的便利方法
Scanner scanner = new Scanner(System.in);
 
// 或者用 BufferedReader 包装，经过 InputStreamReader 桥梁转换
BufferedReader br = new BufferedReader(
    new InputStreamReader(System.in, "UTF-8")  // 字节流 → 字符流
);
String line = br.readLine();  // 读取一行用户输入

// === 示例 1：逐字节读取文件 ===
import java.io.FileInputStream;
import java.io.IOException;
 
public class SingleByteRead {
    public static void main(String[] args) {
        // try-with-resources 自动关闭流，无需手动 close
        try (FileInputStream fis = new FileInputStream("demo.txt")) {
            int data; // 用 int 接收，因为需要判断 -1
            // read() 每次返回一个字节(0~255)，到末尾返回 -1
            while ((data = fis.read()) != -1) {
                // 将 int 强转为 char 输出（仅适用于 ASCII / 单字节编码）
                System.out.print((char) data);
            }
        } catch (IOException e) {
            // IO 操作必须处理受检异常
            e.printStackTrace();
        }
    }
}

// === 示例 2：批量读取（推荐方式） ===
import java.io.FileInputStream;
import java.io.IOException;
 
public class BufferRead {
    public static void main(String[] args) {
        // 分配 1024 字节的缓冲区（buffer）
        byte[] buffer = new byte[1024];
        int bytesRead; // 记录每次实际读到的字节数
 
        try (FileInputStream fis = new FileInputStream("demo.txt")) {
            // read(buffer) 尝试一次性读取 buffer.length 个字节
            // 返回值是实际读到的字节数，到末尾返回 -1
            while ((bytesRead = fis.read(buffer)) != -1) {
                // 只处理 buffer 中 0 ~ bytesRead-1 的有效数据
                // 不能直接 new String(buffer)，否则会包含上一轮的残留数据
                String chunk = new String(buffer, 0, bytesRead);
                System.out.print(chunk);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// === 示例 3：从内存字节数组读取 ===
import java.io.ByteArrayInputStream;
import java.io.IOException;
 
public class MemoryStreamDemo {
    public static void main(String[] args) throws IOException {
        // 源数据：一个普通的字节数组
        byte[] source = "Hello, InputStream!".getBytes();
 
        // 将字节数组包装为 InputStream
        // 之后的代码完全不关心数据来源是文件还是内存
        try (ByteArrayInputStream bais = new ByteArrayInputStream(source)) {
            byte[] buffer = new byte[8]; // 故意用小 buffer 演示多次读取
            int bytesRead;
            while ((bytesRead = bais.read(buffer)) != -1) {
                // 每次最多读 8 字节
                System.out.print(new String(buffer, 0, bytesRead));
            }
        }
        // 输出: Hello, InputStream!
    }
}

// === 示例 4：mark / reset 演示 ===
import java.io.ByteArrayInputStream;
import java.io.IOException;
 
public class MarkResetDemo {
    public static void main(String[] args) throws IOException {
        byte[] data = {65, 66, 67, 68, 69}; // A B C D E
        try (ByteArrayInputStream bais = new ByteArrayInputStream(data)) {
            // 先检查是否支持 mark/reset
            System.out.println("markSupported: " + bais.markSupported()); // true
 
            System.out.print((char) bais.read()); // 读出 A，指针移到 B
            bais.mark(10); // 在 B 的位置打书签，readlimit=10 表示最多向前读 10 字节后书签仍有效
            System.out.print((char) bais.read()); // 读出 B
            System.out.print((char) bais.read()); // 读出 C
 
            bais.reset(); // 回到书签位置（B）
            System.out.print((char) bais.read()); // 再次读出 B
            System.out.print((char) bais.read()); // 再次读出 C
        }
        // 输出: ABCBC
    }
}

// === 示例 5：写入文件（覆盖模式 vs 追加模式） ===
import java.io.FileOutputStream;
import java.io.IOException;
 
public class FileOutputDemo {
    public static void main(String[] args) {
        // --- 覆盖模式（默认）：文件已存在则清空 ---
        try (FileOutputStream fos = new FileOutputStream("output.txt")) {
            String text = "第一行内容\n";
            // getBytes() 使用平台默认编码将字符串转为字节数组
            byte[] bytes = text.getBytes();
            // 将字节数组写入文件
            fos.write(bytes);
        } catch (IOException e) {
            e.printStackTrace();
        }
 
        // --- 追加模式：第二个参数传 true ---
        try (FileOutputStream fos = new FileOutputStream("output.txt", true)) {
            String text = "追加的第二行\n";
            fos.write(text.getBytes());
            // flush() 确保数据从 JVM 缓冲区刷到操作系统
            // 对 FileOutputStream 来说不是必须的，但养成好习惯
            fos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// === 示例 6：字节流文件复制 ===
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
 
public class FileCopy {
    public static void main(String[] args) {
        // 源文件和目标文件路径
        String src = "source.jpg";  // 字节流可以处理任意文件类型（图片、视频等）
        String dest = "copy.jpg";
 
        // 同时打开输入流和输出流
        try (FileInputStream fis = new FileInputStream(src);
             FileOutputStream fos = new FileOutputStream(dest)) {
 
            byte[] buffer = new byte[4096]; // 4KB 缓冲区，兼顾性能和内存
            int bytesRead;
 
            // 核心循环：从源读 → 往目标写
            while ((bytesRead = fis.read(buffer)) != -1) {
                // 注意：必须用三参数版本的 write
                // 只写入 buffer 中 0 ~ bytesRead 的有效数据
                fos.write(buffer, 0, bytesRead);
            }
 
            // try 块结束时自动 close，close 内部会先 flush
            System.out.println("文件复制完成");
 
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// === 示例 7：在内存中拼接字节数据 ===
import java.io.ByteArrayOutputStream;
import java.io.IOException;
 
public class CollectBytesDemo {
    public static void main(String[] args) throws IOException {
        try (ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            // 多次写入，数据在内存中累积
            baos.write("Hello ".getBytes());
            baos.write("World".getBytes());
            baos.write('!'); // 写入单个字节（ASCII 33）
 
            // toByteArray() 获取内部累积的全部字节
            byte[] result = baos.toByteArray();
            System.out.println(new String(result)); // Hello World!
 
            // toString() 也可以直接转字符串（使用平台默认编码）
            System.out.println(baos.toString());
        }
    }
}

// === 示例 8：装饰器模式实战 —— 层层包装 ===
import java.io.*;
 
public class DecoratorDemo {
    public static void main(String[] args) {
        try (
            // 第 1 层：节点流，绑定文件
            FileInputStream fis = new FileInputStream("data.bin");
            // 第 2 层：加缓冲，减少磁盘 I/O 次数
            BufferedInputStream bis = new BufferedInputStream(fis, 8192);
            // 第 3 层：加数据类型读取能力
            DataInputStream dis = new DataInputStream(bis)
        ) {
            // 现在可以直接读取 Java 基本类型
            int number = dis.readInt();       // 读 4 字节，组装成 int
            double value = dis.readDouble();  // 读 8 字节，组装成 double
            String text = dis.readUTF();      // 读 modified UTF-8 字符串
 
            System.out.println(number + ", " + value + ", " + text);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// === 反面教材：Java 7 之前的写法 ===
FileInputStream fis = null;
try {
    fis = new FileInputStream("demo.txt");
    // ... 读取操作 ...
} catch (IOException e) {
    e.printStackTrace();
} finally {
    // 必须在 finally 中关闭，确保异常时也能释放资源
    if (fis != null) {
        try {
            fis.close(); // close 本身也可能抛异常！
        } catch (IOException e) {
            e.printStackTrace(); // 吞掉异常，或者用 addSuppressed
        }
    }
}

// === 推荐写法：try-with-resources ===
try (FileInputStream fis = new FileInputStream("demo.txt")) {
    // 读取操作...
    // 无论正常结束还是抛异常，fis.close() 都会被自动调用
} catch (IOException e) {
    e.printStackTrace();
}
// 简洁、安全、不会泄漏资源

// === 示例 9：Java 9+ 的便捷 API ===
import java.io.*;
 
public class Java9StreamDemo {
    public static void main(String[] args) throws IOException {
        // readAllBytes()：一次性读取全部内容到 byte[]
        // 适合小文件，大文件会 OOM
        try (InputStream is = new FileInputStream("small.txt")) {
            byte[] all = is.readAllBytes(); // Java 9+
            System.out.println(new String(all));
        }
 
        // transferTo()：直接把输入流的内容全部写入输出流
        // 替代了手写的 while-read-write 循环
        try (InputStream in = new FileInputStream("source.dat");
             OutputStream out = new FileOutputStream("target.dat")) {
            long bytes = in.transferTo(out); // Java 9+
            System.out.println("传输了 " + bytes + " 字节");
        }
 
        // readNBytes(int len)：精确读取 len 个字节
        // 与 read(byte[]) 不同，它会反复读直到凑够 len 或到达 EOF
        try (InputStream is = new FileInputStream("data.bin")) {
            byte[] header = is.readNBytes(16); // 精确读取文件头 16 字节
            // header.length <= 16，如果文件不足 16 字节则返回实际长度
        }
    }
}

try (FileInputStream fis = new FileInputStream("photo.png");
     FileOutputStream fos = new FileOutputStream("photo_copy.png")) {
    byte[] buffer = new byte[2048];
    while (fis.read(buffer) != -1) {
        fos.write(buffer);
    }
}

// ===== java.io.Reader 核心 API =====
 
// 读取单个字符，返回值为 int（0~65535），到达末尾返回 -1
public int read() throws IOException
 
// 将字符读入数组 cbuf，返回实际读取的字符数，到达末尾返回 -1
public int read(char[] cbuf) throws IOException
 
// 将字符读入数组 cbuf 的指定区间 [off, off+len)，这是唯一的抽象方法
public abstract int read(char[] cbuf, int off, int len) throws IOException
 
// 跳过 n 个字符
public long skip(long n) throws IOException
 
// 判断流是否准备好被读取（不会阻塞）
public boolean ready() throws IOException
 
// 关闭流并释放资源
public abstract void close() throws IOException

// ===== 使用 FileReader 逐字符读取文本文件 =====
import java.io.FileReader;
import java.io.IOException;
 
public class FileReaderDemo {
    public static void main(String[] args) {
        // try-with-resources 自动关闭流
        try (FileReader reader = new FileReader("hello.txt")) {
            int ch; // 用 int 接收，因为需要判断 -1
            // read() 每次读取一个字符，到达文件末尾时返回 -1
            while ((ch = reader.read()) != -1) {
                // 将 int 强转为 char 以打印可读字符
                System.out.print((char) ch);
            }
        } catch (IOException e) {
            // 处理文件不存在、权限不足等异常
            e.printStackTrace();
        }
    }
}

// ===== 使用 char[] 缓冲区批量读取 =====
import java.io.FileReader;
import java.io.IOException;
 
public class FileReaderBatchDemo {
    public static void main(String[] args) {
        try (FileReader reader = new FileReader("hello.txt")) {
            // 创建一个 1024 字符的缓冲区
            char[] buffer = new char[1024];
            int len; // 记录每次实际读取的字符数
            // read(buffer) 将字符填入数组，返回实际读取数量
            while ((len = reader.read(buffer)) != -1) {
                // 只取 buffer 中 [0, len) 范围的有效字符
                String chunk = new String(buffer, 0, len);
                System.out.print(chunk);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// ===== java.io.Writer 核心 API =====
 
// 写入单个字符（int 的低 16 位）
public void write(int c) throws IOException
 
// 写入整个字符数组
public void write(char[] cbuf) throws IOException
 
// 写入字符数组的指定区间 [off, off+len)，这是唯一的抽象方法
public abstract void write(char[] cbuf, int off, int len) throws IOException
 
// 直接写入一个字符串（Writer 独有的便利方法！）
public void write(String str) throws IOException
 
// 写入字符串的指定区间 [off, off+len)
public void write(String str, int off, int len) throws IOException
 
// 将缓冲区中的数据强制刷出到目标设备
public abstract void flush() throws IOException
 
// 关闭流（关闭前会自动 flush）
public abstract void close() throws IOException

// ===== 使用 FileWriter 写入文本文件 =====
import java.io.FileWriter;
import java.io.IOException;
 
public class FileWriterDemo {
    public static void main(String[] args) {
        // 第二个参数 true 表示追加模式（append），默认 false 会覆盖原文件
        try (FileWriter writer = new FileWriter("output.txt", true)) {
            // 直接写入字符串 —— 这是 Writer 相比 OutputStream 的优势
            writer.write("你好，Java 字符流！\n");
            // 写入单个字符
            writer.write('A');
            // 写入字符数组
            char[] data = {'H', 'e', 'l', 'l', 'o'};
            writer.write(data);
            // flush() 确保数据从内存缓冲区写入磁盘
            // try-with-resources 的 close() 会自动调用 flush()，这里显式调用只是演示
            writer.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// ===== 使用字符流拷贝文本文件 =====
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
 
public class CharFileCopy {
    public static void main(String[] args) {
        // 同时打开输入流和输出流，用分号分隔
        try (FileReader reader = new FileReader("source.txt");
             FileWriter writer = new FileWriter("target.txt")) {
 
            char[] buffer = new char[1024]; // 1K 字符缓冲区
            int len; // 每次实际读取的字符数
 
            // 经典循环：读 → 写 → 读 → 写 ... 直到 -1
            while ((len = reader.read(buffer)) != -1) {
                // 只写入实际读取的字符数量，避免写入脏数据
                writer.write(buffer, 0, len);
            }
            // 循环结束，文件拷贝完成
            // close() 由 try-with-resources 自动调用
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// ===== PrintWriter 的多种构造方式与使用 =====
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
 
public class PrintWriterDemo {
    public static void main(String[] args) throws IOException {
        // 构造方式 1：直接传文件名
        // 构造方式 2：包装一个 Writer，第二个参数 true 开启 autoFlush
        PrintWriter pw = new PrintWriter(new FileWriter("log.txt", true), true);
 
        // print() —— 不换行
        pw.print("用户登录：");
        // println() —— 自动追加平台相关的换行符
        pw.println("admin");
        // printf() / format() —— C 风格格式化输出
        pw.printf("登录时间：%tF %tT%n", System.currentTimeMillis(), System.currentTimeMillis());
        // %tF → 日期 (2025-01-15)
        // %tT → 时间 (14:30:00)
        // %n  → 平台无关的换行符（比 \n 更安全）
 
        pw.close(); // 关闭流
    }
}

// ===== StringReader：从字符串中读取字符 =====
import java.io.IOException;
import java.io.StringReader;
 
public class StringReaderDemo {
    public static void main(String[] args) throws IOException {
        // 将一个 String 包装成 Reader，无需文件
        String source = "Hello, 字符流!";
        StringReader reader = new StringReader(source);
 
        int ch;
        // 逐字符读取，与 FileReader 用法完全一致
        while ((ch = reader.read()) != -1) {
            System.out.print((char) ch + " ");
        }
        // 输出: H e l l o ,   字 符 流 !
        reader.close();
    }
}

// ===== StringWriter：将字符写入内存中的 StringBuffer =====
import java.io.StringWriter;
 
public class StringWriterDemo {
    public static void main(String[] args) {
        StringWriter writer = new StringWriter();
 
        // 像普通 Writer 一样写入
        writer.write("SELECT * FROM users");
        writer.write(" WHERE id = ");
        writer.write(String.valueOf(42));
 
        // 通过 toString() 获取最终拼接的字符串
        String sql = writer.toString();
        System.out.println(sql);
        // 输出: SELECT * FROM users WHERE id = 42
 
        // StringWriter 的 close() 是空操作，不会抛异常
        // 但养成关闭的习惯是好的
        writer.close();
    }
}

// FileReader 读取 UTF-8 文件的内部流转过程
 
// 磁盘文件 (UTF-8 编码)
// "你" 的 UTF-8 编码: E4 BD A0 (3 个字节)
//
// ┌─────────────────────────────────────────────────────────┐
// │                    磁盘 (Disk)                           │
// │   hello.txt: [E4] [BD] [A0] [48] [69]                  │
// │               ─────────────   ───  ───                  │
// │               "你" (3 bytes)  "H"  "i"                  │
// └──────────────────────┬──────────────────────────────────┘
//                        │ FileInputStream.read()
//                        ▼
// ┌─────────────────────────────────────────────────────────┐
// │              FileInputStream (字节流层)                   │
// │   读出原始字节: E4, BD, A0, 48, 69                       │
// └──────────────────────┬──────────────────────────────────┘
//                        │ StreamDecoder 解码 (UTF-8 → char)
//                        ▼
// ┌─────────────────────────────────────────────────────────┐
// │         InputStreamReader / FileReader (字符流层)         │
// │   解码后的字符: '你'(0x4F60), 'H'(0x48), 'i'(0x69)      │
// │                                                         │
// │   '你' 的 Unicode 码点: U+4F60                           │
// │   E4 BD A0 → 经 UTF-8 解码规则 → 0x4F60 → char '你'     │
// └──────────────────────┬──────────────────────────────────┘
//                        │ reader.read()
//                        ▼
// ┌─────────────────────────────────────────────────────────┐
// │                  你的 Java 程序                           │
// │   int ch = reader.read();  // ch = 0x4F60 = 20320      │
// │   char c = (char) ch;      // c = '你'                  │
// └─────────────────────────────────────────────────────────┘

// ===== Java 8 及之前：FileReader 无法指定编码 =====
// 在 Windows (GBK) 上读取 UTF-8 文件 → 乱码！
FileReader reader = new FileReader("utf8_file.txt"); // 使用平台默认编码 GBK
 
// ===== 正确做法：使用 InputStreamReader 显式指定编码 =====
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
 
// 手动构建：FileInputStream → InputStreamReader(指定 UTF-8)
InputStreamReader reader = new InputStreamReader(
    new FileInputStream("utf8_file.txt"),
    StandardCharsets.UTF_8  // 显式指定编码，不依赖平台默认值
);

// ===== Java 11+：FileReader 终于支持指定编码了 =====
import java.io.FileReader;
import java.nio.charset.StandardCharsets;
 
// 新增的构造方法，第二个参数为 Charset
FileReader reader = new FileReader("utf8_file.txt", StandardCharsets.UTF_8);

// ===== 字符流的装饰器链 =====
import java.io.*;
import java.nio.charset.StandardCharsets;
 
public class DecoratorChainDemo {
    public static void main(String[] args) throws IOException {
        // 第 1 层：FileInputStream —— 从文件读取原始字节
        FileInputStream fis = new FileInputStream("data.txt");
 
        // 第 2 层：InputStreamReader —— 字节 → 字符，指定 UTF-8 编码
        InputStreamReader isr = new InputStreamReader(fis, StandardCharsets.UTF_8);
 
        // 第 3 层：BufferedReader —— 添加缓冲 + readLine() 能力
        BufferedReader br = new BufferedReader(isr);
 
        // 现在 br 同时具备：文件读取 + 编码转换 + 缓冲 三种能力
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
 
        br.close(); // 关闭最外层即可，会自动逐层关闭内部流
    }
}

// ❌ 错误：用 FileReader 拷贝图片
FileReader reader = new FileReader("photo.jpg");   // 字节被解码为字符
FileWriter writer = new FileWriter("copy.jpg");    // 字符被重新编码为字节
// 解码 → 编码的过程会破坏原始字节序列，文件损坏！
 
// ✅ 正确：用字节流处理二进制文件
FileInputStream fis = new FileInputStream("photo.jpg");
FileOutputStream fos = new FileOutputStream("copy.jpg");

// ❌ 危险：没有 close 也没有 flush
FileWriter writer = new FileWriter("important.txt");
writer.write("关键数据");
// 程序崩溃或 System.exit() → 缓冲区中的数据永远丢失
 
// ✅ 安全：使用 try-with-resources
try (FileWriter writer = new FileWriter("important.txt")) {
    writer.write("关键数据");
} // close() 自动调用，内部会先 flush() 再释放资源

// ❌ 隐患：依赖平台默认编码，跨平台部署时可能乱码
FileReader reader = new FileReader("config.txt");
 
// ✅ 推荐：显式指定编码
// Java 11+ 写法
FileReader reader = new FileReader("config.txt", StandardCharsets.UTF_8);
// Java 8 兼容写法
InputStreamReader reader = new InputStreamReader(
    new FileInputStream("config.txt"), StandardCharsets.UTF_8
);

// ⚠️ 注意：BufferedReader.readLine() 会吞掉换行符
BufferedReader br = new BufferedReader(new FileReader("poem.txt"));
String line;
StringBuilder sb = new StringBuilder();
while ((line = br.readLine()) != null) {
    // line 中不包含 \n 或 \r\n
    sb.append(line);
    // 如果需要保留换行，必须手动追加
    sb.append(System.lineSeparator());
}

FileReader reader = new FileReader("hello.txt");
char[] buf = new char[10];
int len = reader.read(buf);
System.out.println(new String(buf, 0, len));
reader.close();

// ===== BufferedInputStream 读取原理的简化模型 =====
 
// 内部维护的核心字段（源码简化）
byte[] buf = new byte[8192];  // 缓冲区数组，默认 8KB
int count = 0;                // 缓冲区中实际有效的字节数
int pos = 0;                  // 当前读取位置（游标）
 
// 当调用 read() 时的逻辑（伪代码）
public int read() {
    if (pos >= count) {
        // 缓冲区已耗尽，从底层流批量填充
        count = underlyingStream.read(buf, 0, buf.length);
        pos = 0;                // 重置游标到起点
        if (count <= 0) {
            return -1;          // 底层流也没数据了，返回 EOF
        }
    }
    // 直接从缓冲区取一个字节，游标后移
    return buf[pos++] & 0xFF;   // & 0xFF 确保返回 0~255 的无符号值
}

// ===== 缓冲区状态变化示意 =====
 
// 【状态1】刚填充完毕，pos=0, count=8192
// buf: [B0][B1][B2][B3]...[B8191]
//       ^pos                      ^count
//       ↑ 下次 read() 从这里取
 
// 【状态2】读了3个字节后，pos=3
// buf: [B0][B1][B2][B3][B4]...[B8191]
//                   ^pos              ^count
//                   ↑ 下次 read() 从这里取
 
// 【状态3】全部读完，pos=count=8192，触发下一次批量填充
// buf: [B0][B1][B2]...[B8191]
//                             ^pos=count
//                             ↑ 缓冲区耗尽！重新 fill()

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
 
public class BufferedInputStreamDemo {
    public static void main(String[] args) {
        // ===== 基本用法：包装 FileInputStream =====
        // try-with-resources 自动关闭外层流，内层流会被级联关闭
        try (BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream("data.bin"),  // 被包装的底层字节流
                16384                              // 自定义缓冲区大小：16KB
        )) {
            int byteData;  // 用 int 接收，因为 read() 返回 0~255 或 -1
 
            // 逐字节读取——但实际上每 16KB 才触发一次真正的磁盘 I/O
            while ((byteData = bis.read()) != -1) {
                // 处理每个字节
                System.out.print((char) byteData);
            }
 
        } catch (IOException e) {
            e.printStackTrace();  // 生产环境应使用日志框架
        }
    }
}

import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.IOException;
 
public class MarkResetDemo {
    public static void main(String[] args) throws IOException {
        // 用 ByteArrayInputStream 模拟数据源，方便演示
        byte[] data = "ABCDEFGHIJ".getBytes();  // 10 个字节的测试数据
        BufferedInputStream bis = new BufferedInputStream(
                new ByteArrayInputStream(data)
        );
 
        // 读取前两个字节：A, B
        System.out.println((char) bis.read());  // 输出: A
        System.out.println((char) bis.read());  // 输出: B
 
        // 在当前位置（第3个字节 C 之前）打标记
        // readlimit=5 表示：标记后最多再读5个字节，标记仍然有效
        bis.mark(5);
 
        // 继续读取 3 个字节：C, D, E
        System.out.println((char) bis.read());  // 输出: C
        System.out.println((char) bis.read());  // 输出: D
        System.out.println((char) bis.read());  // 输出: E
 
        // 调用 reset()，回退到 mark() 的位置
        bis.reset();
 
        // 重新从 C 开始读
        System.out.println((char) bis.read());  // 输出: C  ← 又回来了！
        System.out.println((char) bis.read());  // 输出: D
 
        bis.close();  // 关闭流释放资源
    }
}

// ===== mark/reset 位置变化示意 =====
 
// 数据:  [A][B][C][D][E][F][G][H][I][J]
//
// 读完 A, B 后:
//              ^pos=2
//
// 调用 mark(5):
//              ^pos=2, markPos=2
//
// 继续读 C, D, E:
//                       ^pos=5, markPos=2 (距离=3, < readlimit=5, 标记有效)
//
// 调用 reset():
//              ^pos=2 (回退到 markPos!)
//
// 再读:
//              C  D  ...

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
 
public class BufferedOutputStreamDemo {
    public static void main(String[] args) {
        // 包装 FileOutputStream，使用默认 8KB 缓冲区
        try (BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("output.bin")
        )) {
            // 写入单个字节——数据先进入缓冲区，不会立即写磁盘
            bos.write(65);  // 写入字节 65，即字符 'A'
 
            // 写入字节数组——同样先进缓冲区
            byte[] data = "Hello, Buffered World!".getBytes();
            bos.write(data);           // 写入整个数组
            bos.write(data, 0, 5);     // 写入数组的前 5 个字节: "Hello"
 
            // 手动刷新：强制将缓冲区中的数据写入底层流
            bos.flush();
 
            // 注意：try-with-resources 在 close() 时会自动调用 flush()
            // 但如果在 close() 之前程序崩溃，未 flush 的数据就丢了
            // 所以关键节点手动 flush() 是好习惯
 
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
 
public class BufferedReaderDemo {
    public static void main(String[] args) {
        // ===== 经典用法：逐行读取文本文件 =====
        try (BufferedReader br = new BufferedReader(
                new FileReader("poem.txt")  // FileReader 是字符流，处理文本文件
        )) {
            String line;  // 用于接收每一行的内容
 
            // readLine() 读取一行文本（不包含换行符）
            // 到达文件末尾时返回 null
            while ((line = br.readLine()) != null) {
                System.out.println(line);  // 逐行输出
            }
 
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.List;
import java.util.stream.Collectors;
 
public class BufferedReaderStreamDemo {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("log.txt"))) {
 
            // 使用 Stream API 进行声明式的文本处理
            List<String> errorLines = br.lines()          // 返回 Stream<String>，惰性求值
                    .filter(line -> line.contains("ERROR"))  // 只保留包含 "ERROR" 的行
                    .map(String::trim)                       // 去除首尾空白
                    .collect(Collectors.toList());           // 收集为 List
 
            // 输出所有错误行
            errorLines.forEach(System.out::println);
 
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
 
public class BufferedWriterDemo {
    public static void main(String[] args) {
        // 第二个参数 true 表示追加模式（append），不会覆盖已有内容
        try (BufferedWriter bw = new BufferedWriter(
                new FileWriter("output.txt", true)
        )) {
            bw.write("第一行内容");   // 写入字符串，进入缓冲区
            bw.newLine();             // 写入平台相关的换行符
            bw.write("第二行内容");
            bw.newLine();
 
            // 写入字符数组的一部分
            char[] chars = "ABCDEFG".toCharArray();
            bw.write(chars, 2, 3);   // 从索引2开始写3个字符: "CDE"
            bw.newLine();
 
            bw.flush();  // 确保数据写出
 
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.*;
 
public class BufferPerformanceTest {
    public static void main(String[] args) throws IOException {
        // 先创建一个 10MB 的测试文件
        String filename = "testfile_10mb.dat";
        createTestFile(filename, 10 * 1024 * 1024);  // 10MB
 
        // ===== 测试1：无缓冲，逐字节读取 =====
        long start1 = System.currentTimeMillis();       // 记录开始时间
        try (FileInputStream fis = new FileInputStream(filename)) {
            while (fis.read() != -1) {
                // 每次 read() 都是一次系统调用（理论上）
            }
        }
        long time1 = System.currentTimeMillis() - start1;
        System.out.println("无缓冲逐字节读取: " + time1 + " ms");
 
        // ===== 测试2：有缓冲，逐字节读取 =====
        long start2 = System.currentTimeMillis();
        try (BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream(filename)
        )) {
            while (bis.read() != -1) {
                // 每次 read() 大多数时候只是从内存数组取数据
            }
        }
        long time2 = System.currentTimeMillis() - start2;
        System.out.println("有缓冲逐字节读取: " + time2 + " ms");
 
        // ===== 测试3：无缓冲，手动数组批量读取 =====
        long start3 = System.currentTimeMillis();
        try (FileInputStream fis = new FileInputStream(filename)) {
            byte[] buf = new byte[8192];               // 手动创建 8KB 缓冲数组
            while (fis.read(buf) != -1) {
                // 每次读取最多 8192 字节
            }
        }
        long time3 = System.currentTimeMillis() - start3;
        System.out.println("无缓冲+手动数组读取: " + time3 + " ms");
 
        // 输出性能倍数对比
        System.out.println("缓冲流比无缓冲快约: " + (time1 / Math.max(time2, 1)) + " 倍");
    }
 
    // 创建指定大小的测试文件
    private static void createTestFile(String name, int size) throws IOException {
        try (FileOutputStream fos = new FileOutputStream(name)) {
            byte[] chunk = new byte[4096];  // 每次写 4KB
            int written = 0;                // 已写入字节数
            while (written < size) {
                fos.write(chunk);           // 写入一块全零数据
                written += chunk.length;    // 累加
            }
        }
    }
}

// ✅ 正确：只关闭最外层
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
br.close();  // 内部的 FileReader 会被自动关闭
 
// ❌ 错误：重复关闭
FileReader fr = new FileReader("a.txt");
BufferedReader br2 = new BufferedReader(fr);
br2.close();
fr.close();  // 多余！可能抛出异常（流已关闭）

// ❌ 危险：没有 flush，如果程序异常退出，数据可能丢失
BufferedWriter bw = new BufferedWriter(new FileWriter("data.txt"));
bw.write("重要数据");
// 程序在这里崩溃了... 数据还在缓冲区里，没写入文件！
 
// ✅ 安全：使用 try-with-resources，close() 会自动 flush
try (BufferedWriter bw2 = new BufferedWriter(new FileWriter("data.txt"))) {
    bw2.write("重要数据");
}  // 这里自动 close() → 自动 flush() → 数据安全落盘

// 大文件处理：使用 64KB 缓冲区
int bufferSize = 64 * 1024;  // 64KB
BufferedInputStream bis = new BufferedInputStream(
        new FileInputStream("huge_file.dat"),
        bufferSize  // 自定义缓冲区大小
);

// ❌ 毫无意义：双重缓冲只是浪费内存
BufferedInputStream bis = new BufferedInputStream(
        new BufferedInputStream(new FileInputStream("a.txt"))
);
 
// ✅ 一层缓冲就够了
BufferedInputStream bis2 = new BufferedInputStream(
        new FileInputStream("a.txt")
);

// 装饰器的自由组合——从内到外层层包装
// 第1层：FileInputStream 负责从文件读取原始字节
// 第2层：BufferedInputStream 增加缓冲能力
// 第3层：DataInputStream 增加读取基本类型的能力
DataInputStream dis = new DataInputStream(     // 最外层：读 int, double 等
    new BufferedInputStream(                    // 中间层：缓冲加速
        new FileInputStream("data.bin")         // 最内层：文件数据源
    )
);
 
int value = dis.readInt();      // 读取一个 4 字节的 int
double pi = dis.readDouble();   // 读取一个 8 字节的 double
dis.close();                    // 关闭最外层，级联关闭所有层

BufferedWriter bw = new BufferedWriter(new FileWriter("result.txt"));
bw.write("Hello");
bw.write(" World");
bw.close();
// 再次打开，注意没有 append 模式
BufferedWriter bw2 = new BufferedWriter(new FileWriter("result.txt"));
bw2.write("Java");
bw2.flush();
bw2.close();

// 演示编码与解码的本质
public class EncodingDemo {
    public static void main(String[] args) throws Exception {
        String text = "你好";  // Java 内部以 UTF-16 存储
 
        // 编码：字符 → 字节（使用 UTF-8）
        byte[] utf8Bytes = text.getBytes("UTF-8");       // [0xE4,0xBD,0xA0,0xE5,0xA5,0xBD] 共6字节
        // 编码：字符 → 字节（使用 GBK）
        byte[] gbkBytes = text.getBytes("GBK");           // [0xC4,0xE3,0xBA,0xC3] 共4字节
 
        // 正确解码：UTF-8 字节用 UTF-8 解码
        String correct = new String(utf8Bytes, "UTF-8");   // "你好" ✅
        // 错误解码：UTF-8 字节用 GBK 解码
        String wrong = new String(utf8Bytes, "GBK");       // "浣犲ソ" ❌ 乱码！
 
        System.out.println("UTF-8 字节数: " + utf8Bytes.length);  // 6
        System.out.println("GBK 字节数: " + gbkBytes.length);      // 4
        System.out.println("正确解码: " + correct);                  // 你好
        System.out.println("错误解码: " + wrong);                    // 乱码
    }
}

// 构造方法1：使用平台默认编码（不推荐，因为不同系统默认编码不同）
public InputStreamReader(InputStream in)
 
// 构造方法2：显式指定编码名称（推荐）
public InputStreamReader(InputStream in, String charsetName) throws UnsupportedEncodingException
 
// 构造方法3：使用 Charset 对象指定编码（推荐，编译期安全）
public InputStreamReader(InputStream in, Charset cs)
 
// 构造方法4：使用 CharsetDecoder 指定解码器（高级用法）
public InputStreamReader(InputStream in, CharsetDecoder dec)

import java.io.*;
 
public class ConsoleReadDemo {
    public static void main(String[] args) throws IOException {
        // System.in 是 InputStream（字节流），无法直接按行读取
        // 第一层包装：InputStreamReader 将字节流转为字符流，指定 UTF-8 编码
        InputStreamReader isr = new InputStreamReader(System.in, "UTF-8");
        // 第二层包装：BufferedReader 提供缓冲和 readLine() 能力
        BufferedReader br = new BufferedReader(isr);
 
        System.out.println("请输入内容（输入 quit 退出）：");
 
        String line;  // 用于存储每次读取的一行文本
        // readLine() 会阻塞等待用户输入，遇到换行符返回该行内容
        while ((line = br.readLine()) != null) {
            if ("quit".equalsIgnoreCase(line)) {  // 忽略大小写比较
                break;  // 用户输入 quit 时退出循环
            }
            System.out.println("你输入了: " + line);  // 回显用户输入
        }
 
        br.close();  // 关闭最外层流即可，会自动关闭内层流
    }
}

import java.io.*;
 
public class ReadGBKFile {
    public static void main(String[] args) {
        // 使用 try-with-resources 确保流自动关闭
        // FileInputStream 打开文件的原始字节流
        // InputStreamReader 以 GBK 编码将字节解码为字符
        // BufferedReader 提供缓冲，提升读取效率
        try (BufferedReader br = new BufferedReader(
                new InputStreamReader(
                        new FileInputStream("data_gbk.txt"), "GBK"))) {
 
            String line;  // 存储每行内容
            // 逐行读取，readLine() 返回 null 表示文件结束
            while ((line = br.readLine()) != null) {
                System.out.println(line);  // 输出每行内容
            }
 
        } catch (UnsupportedEncodingException e) {
            // 编码名称拼写错误时抛出此异常
            System.err.println("不支持的编码: " + e.getMessage());
        } catch (FileNotFoundException e) {
            // 文件不存在时抛出此异常
            System.err.println("文件未找到: " + e.getMessage());
        } catch (IOException e) {
            // 其他 I/O 异常
            e.printStackTrace();
        }
    }
}

// 构造方法1：使用平台默认编码
public OutputStreamWriter(OutputStream out)
 
// 构造方法2：显式指定编码名称（推荐）
public OutputStreamWriter(OutputStream out, String charsetName) throws UnsupportedEncodingException
 
// 构造方法3：使用 Charset 对象（推荐）
public OutputStreamWriter(OutputStream out, Charset cs)
 
// 构造方法4：使用 CharsetEncoder（高级用法）
public OutputStreamWriter(OutputStream out, CharsetEncoder enc)

import java.io.*;
 
public class WriteGBKFile {
    public static void main(String[] args) {
        // FileOutputStream 创建文件的原始字节输出流
        // OutputStreamWriter 以 GBK 编码将字符编码为字节
        // BufferedWriter 提供缓冲，减少实际 I/O 次数
        try (BufferedWriter bw = new BufferedWriter(
                new OutputStreamWriter(
                        new FileOutputStream("output_gbk.txt"), "GBK"))) {
 
            bw.write("你好，世界！");  // 写入中文内容
            bw.newLine();               // 写入平台相关的换行符
            bw.write("Hello, World!");  // 写入英文内容
            bw.newLine();               // 再写一个换行
            bw.flush();                 // 强制将缓冲区内容刷出到底层流
 
        } catch (IOException e) {
            e.printStackTrace();  // 打印异常堆栈
        }
        // try-with-resources 结束时自动调用 close()，close() 内部也会 flush()
    }
}

import java.io.*;
 
public class EncodingConverter {
    /**
     * 将文件从一种编码转换为另一种编码
     * @param srcFile    源文件路径
     * @param srcCharset 源文件编码
     * @param destFile   目标文件路径
     * @param destCharset 目标文件编码
     */
    public static void convert(String srcFile, String srcCharset,
                               String destFile, String destCharset)
            throws IOException {
 
        // 输入端：以源编码读取字节，解码为字符
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(
                        new FileInputStream(srcFile), srcCharset));
             // 输出端：将字符以目标编码编码为字节，写出
             BufferedWriter writer = new BufferedWriter(
                new OutputStreamWriter(
                        new FileOutputStream(destFile), destCharset))) {
 
            char[] buffer = new char[4096];  // 4KB 字符缓冲区
            int charsRead;                    // 每次实际读取的字符数
            // read(char[], off, len) 批量读取字符到缓冲区
            while ((charsRead = reader.read(buffer, 0, buffer.length)) != -1) {
                // 将读取到的字符写出（只写实际读取的部分）
                writer.write(buffer, 0, charsRead);
            }
            // 循环结束意味着源文件读取完毕，所有内容已转码写出
        }
        // try-with-resources 自动关闭 reader 和 writer
    }
 
    public static void main(String[] args) throws IOException {
        // 将 GBK 编码的文件转换为 UTF-8 编码
        convert("legacy_gbk.txt", "GBK", "modern_utf8.txt", "UTF-8");
        System.out.println("编码转换完成！");
    }
}