IO 流¶

    /**
     * FileInputStream：一次读取一个字节
     */
    @Test
    void testFileInputStreamSingleByte() throws IOException {
        // 从类路径获取测试文件
        String path = getClass().getClassLoader()
                .getResource("test-read.txt").getPath();

        try (FileInputStream fis = new FileInputStream(path)) {
            int data;
            StringBuilder sb = new StringBuilder();
            // read() 返回 int（0~255），-1 表示读完
            while ((data = fis.read()) != -1) {
                sb.append((char) data);
            }
            System.out.println("逐字节读取结果: " + sb);
            assertTrue(sb.toString().contains("Hello"), "应包含 Hello");
            // ⚠️ 中文可能出现乱码，因为字节流不处理编码
        }
    }

    /**
     * FileInputStream：一次读取一个字节数组（推荐方式）
     */
    @Test
    void testFileInputStreamByteArray() throws IOException {
        String path = getClass().getClassLoader()
                .getResource("test-read.txt").getPath();

        try (FileInputStream fis = new FileInputStream(path)) {
            byte[] buffer = new byte[1024]; // 1KB 缓冲区
            int bytesRead;
            StringBuilder sb = new StringBuilder();
            while ((bytesRead = fis.read(buffer)) != -1) {
                // 注意用 bytesRead 控制实际读取长度
                sb.append(new String(buffer, 0, bytesRead));
            }
            System.out.println("数组读取结果: " + sb);
            assertTrue(sb.toString().contains("Hello"), "应包含 Hello");
        }
    }

    /**
     * FileOutputStream：覆盖写入和追加写入
     */
    @Test
    void testFileOutputStreamWrite(@TempDir Path tempDir) throws IOException {
        File file = new File(tempDir + "/output.txt");

        // 覆盖写入（默认模式）
        try (FileOutputStream fos = new FileOutputStream(file)) {
            fos.write("Hello, IO!".getBytes());
        }

        // 追加写入（第二个参数为 true）
        try (FileOutputStream fos = new FileOutputStream(file, true)) {
            fos.write("\n追加的内容".getBytes());
        }

        // 验证文件内容
        try (FileInputStream fis = new FileInputStream(file)) {
            String content = new String(fis.readAllBytes());
            assertTrue(content.contains("Hello, IO!"), "应包含原始内容");
            assertTrue(content.contains("追加的内容"), "应包含追加内容");
            System.out.println("文件内容:\n" + content);
        }
    }

    /**
     * 实战：用字节流拷贝文件
     */
    @Test
    void testFileCopy(@TempDir Path tempDir) throws IOException {
        // 准备源文件
        File src = new File(tempDir + "/source.txt");
        try (FileOutputStream fos = new FileOutputStream(src)) {
            fos.write("这是要拷贝的内容，包含中文和 English".getBytes());
        }

        // 执行拷贝
        File dest = new File(tempDir + "/copy.txt");
        try (FileInputStream fis = new FileInputStream(src);
             FileOutputStream fos = new FileOutputStream(dest)) {
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }
        }

        // 验证拷贝结果
        assertTrue(dest.exists(), "目标文件应存在");
        assertEquals(src.length(), dest.length(), "文件大小应一致");
        System.out.println("拷贝成功，文件大小: " + dest.length() + " 字节");
    }

    /**
     * ByteArrayInputStream / ByteArrayOutputStream：内存中的流
     */
    @Test
    void testByteArrayStream() throws IOException {
        // ByteArrayOutputStream：写入内存字节数组
        byte[] result;
        try (ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            baos.write("Hello ".getBytes());
            baos.write("World".getBytes());
            result = baos.toByteArray();
        }
        assertEquals("Hello World", new String(result));

        // ByteArrayInputStream：从字节数组读取
        try (ByteArrayInputStream bais = new ByteArrayInputStream(result)) {
            int data;
            StringBuilder sb = new StringBuilder();
            while ((data = bais.read()) != -1) {
                sb.append((char) data);
            }
            assertEquals("Hello World", sb.toString());
        }
    }

    /**
     * PipedInputStream / PipedOutputStream：线程间通信
     */
    @Test
    void testPipedStream() throws IOException, InterruptedException {
        PipedInputStream pis = new PipedInputStream();
        PipedOutputStream pos = new PipedOutputStream();
        pis.connect(pos); // 建立管道连接

        String message = "Hello from another thread!";

        // 写入线程
        Thread writer = new Thread(() -> {
            try (pos) {
                pos.write(message.getBytes());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        });
        writer.start();

        // 读取线程（当前线程）
        StringBuilder sb = new StringBuilder();
        try (pis) {
            int data;
            while ((data = pis.read()) != -1) {
                sb.append((char) data);
            }
        }

        writer.join(); // 等待写入线程结束
        assertEquals(message, sb.toString());
        System.out.println("管道流接收到: " + sb);
    }

    /**
     * SequenceInputStream：将多个流串联成一个流
     */
    @Test
    void testSequenceInputStream() throws IOException {
        InputStream s1 = new ByteArrayInputStream("Hello ".getBytes());
        InputStream s2 = new ByteArrayInputStream("World".getBytes());
        InputStream s3 = new ByteArrayInputStream("!".getBytes());

        // 方式一：串联两个流
        try (SequenceInputStream sis = new SequenceInputStream(s1, s2)) {
            byte[] result = sis.readAllBytes();
            assertEquals("Hello World", new String(result));
        }

        // 方式二：串联多个流（通过 Enumeration）
        java.util.Vector<InputStream> streams = new java.util.Vector<>();
        streams.add(new ByteArrayInputStream("A".getBytes()));
        streams.add(new ByteArrayInputStream("B".getBytes()));
        streams.add(new ByteArrayInputStream("C".getBytes()));

        try (SequenceInputStream sis = new SequenceInputStream(streams.elements())) {
            assertEquals("ABC", new String(sis.readAllBytes()));
        }
    }

    /**
     * CharArrayReader / CharArrayWriter：内存中的字符流
     */
    @Test
    void testCharArrayReaderWriter() throws IOException {
        // CharArrayWriter：写入内存字符数组
        char[] result;
        try (CharArrayWriter caw = new CharArrayWriter()) {
            caw.write("你好，");
            caw.write("世界！");
            result = caw.toCharArray();
        }
        assertEquals("你好，世界！", new String(result));

        // CharArrayReader：从字符数组读取
        try (CharArrayReader car = new CharArrayReader(result)) {
            StringBuilder sb = new StringBuilder();
            int ch;
            while ((ch = car.read()) != -1) {
                sb.append((char) ch);
            }
            assertEquals("你好，世界！", sb.toString());
        }
    }

    /**
     * StringReader / StringWriter：以 String 为数据源的字符流
     */
    @Test
    void testStringReaderWriter() throws IOException {
        // StringReader：从字符串读取
        String source = "Java IO 流是个大家族\n字节流和字符流各有用武之地";
        try (StringReader sr = new StringReader(source);
             BufferedReader br = new BufferedReader(sr)) {
            // 包装成 BufferedReader 后可以按行读取
            assertEquals("Java IO 流是个大家族", br.readLine());
            assertEquals("字节流和字符流各有用武之地", br.readLine());
            assertNull(br.readLine()); // 没有更多内容
        }

        // StringWriter：写入后得到字符串
        try (StringWriter sw = new StringWriter()) {
            sw.write("第一部分");
            sw.write(" + ");
            sw.write("第二部分");
            assertEquals("第一部分 + 第二部分", sw.toString());
        }
    }

// 自由组合：文件流 → 缓冲 → 按行读取
BufferedReader br = new BufferedReader(   // 第二层：缓冲 + 按行读取
    new InputStreamReader(                 // 第一层：字节转字符（指定编码）
        new FileInputStream("data.txt"),   // 最底层：节点流
        StandardCharsets.UTF_8
    )
);

// BufferedInputStream 的构造方法——接收一个 InputStream
public BufferedInputStream(InputStream in) { ... }

// InputStreamReader 的构造方法——接收一个 InputStream
public InputStreamReader(InputStream in, Charset cs) { ... }

// DataInputStream 的构造方法——接收一个 InputStream
public DataInputStream(InputStream in) { ... }

    /**
     * 转换流：InputStreamReader 指定编码读取
     */
    @Test
    void testInputStreamReader(@TempDir Path tempDir) throws IOException {
        // 先用 UTF-8 编码写入文件
        File file = new File(tempDir + "/utf8.txt");
        try (OutputStreamWriter osw = new OutputStreamWriter(
                new FileOutputStream(file), StandardCharsets.UTF_8)) {
            osw.write("你好，世界！Hello World!");
        }

        // 用 InputStreamReader 指定 UTF-8 解码读取
        try (InputStreamReader isr = new InputStreamReader(
                new FileInputStream(file), StandardCharsets.UTF_8)) {
            char[] buffer = new char[1024];
            int charsRead = isr.read(buffer);
            String content = new String(buffer, 0, charsRead);
            System.out.println("转换流读取: " + content);
            assertTrue(content.contains("你好"), "应正确解码中文");
        }
    }

    /**
     * FileReader / FileWriter：转换流的简化版（使用平台默认编码）
     */
    @Test
    void testFileReaderWriter(@TempDir Path tempDir) throws IOException {
        File file = new File(tempDir + "/text.txt");

        // FileWriter 写入文本
        try (FileWriter fw = new FileWriter(file)) {
            fw.write("用 FileWriter 写入的文本\n");
            fw.write("第二行内容");
        }

        // FileReader 读取文本
        try (FileReader fr = new FileReader(file)) {
            char[] buffer = new char[1024];
            int charsRead = fr.read(buffer);
            String content = new String(buffer, 0, charsRead);
            System.out.println("FileReader 读取:\n" + content);
            assertTrue(content.contains("FileWriter"), "应包含写入内容");
        }
    }

    /**
     * 缓冲流：提升读写性能
     */
    @Test
    void testBufferedStreamCopy(@TempDir Path tempDir) throws IOException {
        // 准备源文件
        File src = new File(tempDir + "/source.dat");
        try (FileOutputStream fos = new FileOutputStream(src)) {
            byte[] data = new byte[10000]; // 10KB 测试数据
            for (int i = 0; i < data.length; i++) {
                data[i] = (byte) (i % 256);
            }
            fos.write(data);
        }

        // 用缓冲流拷贝（性能远优于裸 FileInputStream）
        File dest = new File(tempDir + "/copy.dat");
        try (BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream(src));
             BufferedOutputStream bos = new BufferedOutputStream(
                     new FileOutputStream(dest))) {
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, bytesRead);
            }
        }

        assertEquals(src.length(), dest.length(), "拷贝后文件大小应一致");
        System.out.println("缓冲流拷贝完成，大小: " + dest.length() + " 字节");
    }

    /**
     * BufferedReader：readLine() 按行读取
     */
    @Test
    void testBufferedReaderReadLine() throws IOException {
        String path = getClass().getClassLoader()
                .getResource("lines.txt").getPath();

        try (BufferedReader br = new BufferedReader(new FileReader(path))) {
            String line;
            int lineNumber = 0;
            while ((line = br.readLine()) != null) {
                lineNumber++;
                System.out.printf("第 %d 行: %s%n", lineNumber, line);
            }
            assertTrue(lineNumber > 0, "应至少读到一行");
        }
    }

    /**
     * BufferedReader：mark() 和 reset() 实现回退读取
     */
    @Test
    void testBufferedReaderMarkReset() throws IOException {
        String path = getClass().getClassLoader()
                .getResource("lines.txt").getPath();

        try (BufferedReader br = new BufferedReader(new FileReader(path))) {
            br.mark(1024); // 标记当前位置
            String firstRead = br.readLine();
            System.out.println("第一次读: " + firstRead);

            br.reset(); // 回退到 mark 位置
            String secondRead = br.readLine();
            System.out.println("回退后再读: " + secondRead);

            // 两次读到的应该是同一行
            assertEquals(firstRead, secondRead, "reset 后应重新读取同一行");
        }
    }

    /**
     * 数据流：读写基本数据类型
     */
    @Test
    void testDataStream(@TempDir Path tempDir) throws IOException {
        File file = new File(tempDir + "/data.bin");

        // 写入基本数据类型
        try (DataOutputStream dos = new DataOutputStream(
                new FileOutputStream(file))) {
            dos.writeInt(42);
            dos.writeDouble(3.14);
            dos.writeBoolean(true);
            dos.writeUTF("Hello 数据流");
        }

        // 读取——顺序必须与写入一致！
        try (DataInputStream dis = new DataInputStream(
                new FileInputStream(file))) {
            int i = dis.readInt();
            double d = dis.readDouble();
            boolean b = dis.readBoolean();
            String s = dis.readUTF();

            assertEquals(42, i);
            assertEquals(3.14, d, 0.001);
            assertTrue(b);
            assertEquals("Hello 数据流", s);
            System.out.printf("读取结果: int=%d, double=%.2f, boolean=%s, string=%s%n",
                    i, d, b, s);
        }
    }

package com.luguosong.io;

import java.io.Serial;
import java.io.Serializable;

/**
 * 用于演示对象序列化的实体类
 */
public class User implements Serializable {

    @Serial
    private static final long serialVersionUID = 1L;

    private String name;
    private int age;
    // transient 字段不参与序列化
    private transient String password;

    public User(String name, int age, String password) {
        this.name = name;
        this.age = age;
        this.password = password;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getPassword() {
        return password;
    }

    @Override
    public String toString() {
        return "User{name='%s', age=%d, password='%s'}".formatted(name, age, password);
    }
}

    /**
     * 对象流：序列化与反序列化 Java 对象
     */
    @Test
    void testObjectStream(@TempDir Path tempDir) throws IOException, ClassNotFoundException {
        File file = new File(tempDir + "/user.dat");

        // 序列化：将对象写入文件
        User user = new User("张三", 25, "secret123");
        try (ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream(file))) {
            oos.writeObject(user);
        }

        // 反序列化：从文件还原对象
        try (ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream(file))) {
            User restored = (User) ois.readObject();
            assertEquals("张三", restored.getName());
            assertEquals(25, restored.getAge());
            // transient 字段不参与序列化，还原后为 null
            assertNull(restored.getPassword(), "transient 字段应为 null");
            System.out.println("反序列化: " + restored);
        }
    }

public class User implements Serializable {
    @Serial // Java 14+ 注解，帮助编译器检查序列化相关声明
    private static final long serialVersionUID = 1L;
    // ...
}

    /**
     * 打印流：PrintStream 输出重定向
     */
    @Test
    void testPrintStream(@TempDir Path tempDir) throws IOException {
        File file = new File(tempDir + "/log.txt");

        // 保存原始 System.out
        PrintStream originalOut = System.out;

        try (PrintStream ps = new PrintStream(new FileOutputStream(file))) {
            // 将标准输出重定向到文件
            System.setOut(ps);
            System.out.println("这句话写入文件而非控制台");
            System.out.println(42);
            System.out.println(3.14);
        } finally {
            // 恢复原始 System.out
            System.setOut(originalOut);
        }

        // 验证文件内容
        try (FileInputStream fis = new FileInputStream(file)) {
            String content = new String(fis.readAllBytes());
            assertTrue(content.contains("这句话写入文件"), "日志应写入文件");
        }
        System.out.println("打印流重定向测试通过");
    }

    /**
     * 格式化输出：format() / printf() 和 String.format()
     */
    @Test
    void testFormatOutput() {
        // %d 整数，%f 浮点数，%s 字符串，%n 换行
        String result = String.format("姓名: %s, 年龄: %d, 成绩: %.1f", "张三", 25, 92.567);
        assertEquals("姓名: 张三, 年龄: 25, 成绩: 92.6", result);

        // 宽度与对齐：%10d 右对齐补空格，%-10s 左对齐
        String aligned = String.format("|%10d|%-10s|", 42, "hello");
        assertEquals("|        42|hello     |", aligned);

        // 补零：%05d
        assertEquals("00042", String.format("%05d", 42));

        // 千位分隔符（需要 Locale）
        String grouped = String.format(Locale.US, "%,d", 1234567);
        assertEquals("1,234,567", grouped);

        // 十六进制和八进制
        assertEquals("ff", String.format("%x", 255));
        assertEquals("377", String.format("%o", 255));
    }

    /**
     * 压缩流：GZIP 压缩与解压
     */
    @Test
    void testGzipStream(@TempDir Path tempDir) throws IOException {
        File gzFile = new File(tempDir + "/data.gz");
        String original = "这是一段需要压缩的文本数据。".repeat(100);

        // GZIP 压缩
        try (GZIPOutputStream gos = new GZIPOutputStream(
                new FileOutputStream(gzFile))) {
            gos.write(original.getBytes(StandardCharsets.UTF_8));
        }

        // GZIP 解压——先收集所有字节，再转字符串（避免 UTF-8 多字节字符在缓冲区边界被截断）
        ByteArrayOutputStream collector = new ByteArrayOutputStream();
        try (GZIPInputStream gis = new GZIPInputStream(
                new FileInputStream(gzFile))) {
            byte[] buffer = new byte[1024];
            int len;
            while ((len = gis.read(buffer)) != -1) {
                collector.write(buffer, 0, len);
            }
        }
        String decompressed = collector.toString(StandardCharsets.UTF_8);

        assertEquals(original, decompressed, "解压后应与原文一致");
        System.out.printf("原始大小: %d 字节, 压缩后: %d 字节, 压缩比: %.1f%%%n",
                original.getBytes().length, gzFile.length(),
                (double) gzFile.length() / original.getBytes().length * 100);
    }

// 打包多个文件为 ZIP
try (ZipOutputStream zos = new ZipOutputStream(
        new FileOutputStream("archive.zip"))) {
    // 添加第一个文件
    zos.putNextEntry(new ZipEntry("hello.txt"));
    zos.write("你好".getBytes(StandardCharsets.UTF_8));
    zos.closeEntry();
    // 添加第二个文件
    zos.putNextEntry(new ZipEntry("world.txt"));
    zos.write("世界".getBytes(StandardCharsets.UTF_8));
    zos.closeEntry();
}

// 从 ZIP 中逐个读取
try (ZipInputStream zis = new ZipInputStream(
        new FileInputStream("archive.zip"))) {
    ZipEntry entry;
    while ((entry = zis.getNextEntry()) != null) {
        System.out.println("文件: " + entry.getName());
        // 读取当前条目的内容...
        zis.closeEntry();
    }
}

    /**
     * RandomAccessFile：随机读写文件
     */
    @Test
    void testRandomAccessFile(@TempDir Path tempDir) throws IOException {
        File file = tempDir.resolve("random.dat").toFile();

        // 写入数据：3 个 int（每个占 4 字节）
        try (RandomAccessFile raf = new RandomAccessFile(file, "rw")) {
            raf.writeInt(100);  // 位置 0~3
            raf.writeInt(200);  // 位置 4~7
            raf.writeInt(300);  // 位置 8~11
            raf.writeUTF("你好"); // 位置 12 开始，writeUTF 会先写 2 字节长度
        }

        // 随机读取：直接跳到第 2 个 int 的位置
        try (RandomAccessFile raf = new RandomAccessFile(file, "r")) {
            raf.seek(4); // 跳过第 1 个 int（4 字节），定位到第 2 个
            assertEquals(200, raf.readInt());

            // 回到开头读取第 1 个
            raf.seek(0);
            assertEquals(100, raf.readInt());

            // 跳到第 3 个
            raf.seek(8);
            assertEquals(300, raf.readInt());

            // 读取字符串
            assertEquals("你好", raf.readUTF());
        }

        // 随机修改：只改第 2 个 int，其他不动
        try (RandomAccessFile raf = new RandomAccessFile(file, "rw")) {
            raf.seek(4);
            raf.writeInt(999); // 覆盖位置 4~7 的数据
        }

        // 验证修改结果
        try (RandomAccessFile raf = new RandomAccessFile(file, "r")) {
            assertEquals(100, raf.readInt());  // 第 1 个未变
            assertEquals(999, raf.readInt());  // 第 2 个已修改
            assertEquals(300, raf.readInt());  // 第 3 个未变
        }
    }