6. 字节输出流（OutputStream）

FileOutputStream 负责往文件里写字节，构造的时候指定写到哪个路径。

public static void main(String[] args) throws IOException {
    //创建一个文章输出管道，输出到指定位置。
    FileOutputStream fileOutputStream = new FileOutputStream("test01/src/main/java/org/example/images/output.txt");
    //使用write方法将指定的字节输出到文件中，首先可以写入单个字节
    fileOutputStream.write(97);//把97字节输出到文件里，97对应的是小写a
    fileOutputStream.write('b');//b代表的int类型是98
    //可以写入一个字节数组
    byte[] bytes = "这是一个测试字符串zxcasdqwe".getBytes();//把一个字符串转换成字节数组
    fileOutputStream.write(bytes);
    //可以自定义截取数组的长度
    fileOutputStream.write(bytes, 0, bytes.length - 9);
    /*
     * 最终文件内容是 'ab这是一个测试字符串zxcasdqwe这是一个测试字符串'
     * */
    //每次运行的时候都会把文件覆盖写入，如果想在后面进行追加的话，可以换参数控制，创建一个追加管道
    FileOutputStream fileOutputStreamOne = new FileOutputStream("test01/src/main/java/org/example/images/output.txt", true);
    byte[] bytes1 = "\r\n".getBytes();//实现文件换行
    fileOutputStreamOne.write(bytes1);
    fileOutputStreamOne.write(bytes);
}

截取长度算的是字节不是字符
　　「这是一个测试字符串zxcasdqwe」在 UTF-8 下是 36 字节，不是 17 个字符
　　bytes.length - 9 剩下 27 字节，正好是 9 个汉字，所以结果是「这是一个测试字符串」
　　拿字符串的 length() 去算截断位置，汉字会被切坏
默认是覆盖，不是追加
　　第二个参数传 true 才追加，不传就把文件清空重写
　　日志、配置这类要追加的场景，忘了传 true 就只剩最后一次
write(int) 写的是低 8 位
　　write(97) 写进去是一个字节 97，不是 97 这个字符串
换行符分平台
　　Windows 认 \r\n，Linux 认 \n，要跨平台用 System.lineSeparator()
字符流有 write(String)，字节流没有
　　FileOutputStream 只能写字节，想直接写字符串得先 getBytes()

7. 文件拷贝

拷贝是字节流最典型的用法，一个读一个写，循环搬运。

public static void main(String[] args) throws IOException {
    //根据文件路径创建FileInputStream对象，也可以根据File对象创建管道
    File file = new File("test01/src/main/java/org/example/images/002.png");
    File fileOne = new File("test01/src/main/java/org/example/images/copy002.png");
    FileInputStream fileInputStreamOne = new FileInputStream(file);
    FileOutputStream fileOutputStreamOne = new FileOutputStream(fileOne);
    byte[] buffer = new byte[1024];
    int a;
    while (true) {
        a = fileInputStreamOne.read(buffer);
        if (-1 == a) {
            break;
        }
        fileOutputStreamOne.write(buffer, 0, a);
    }
    System.out.println("文件拷贝完成！");
    //使用完成后必须释放系统资源
    fileOutputStreamOne.close();
    fileInputStreamOne.close();
}

写多少要跟读多少对齐
　　write(buffer, 0, a) 里的 a 是这次真读到的字节数，不能写成 buffer.length
　　写满了，最后一桶会把旧数据糊到文件尾部，文件大小对不上
JDK 9 有更省事的写法
　　fileInputStreamOne.transferTo(fileOutputStreamOne) 一行搞定，连循环都省了
大文件别整个读进内存
　　1024 字节一块地搬，一个 10 GB 的文件内存占用也就 1 KB
源和目标别是同一个文件
　　new FileOutputStream(file) 会先把源文件清空，然后才轮到读，文件直接空了
拷贝完比一下大小
　　file.length() 对比目标文件长度，不一致就说明中间断了
服务端收到上传文件之后也是这套流程
　　完整的接收链路见 Spring Boot 文件上传

8. 管道的关闭

运行完后管道需要关闭，这是就需要把 close 方法写到 finally 之中。

Java 7 之后别再手写 finally
　　try-with-resources 把流声明写在括号里，用完自动关，抛异常也关
　　手写 finally 的话，close 自己抛异常会把原来的异常盖掉，排查时看到的是错的那个
没关的流会漏文件句柄
　　Windows 上句柄有上限，漏多了就报「文件 too many open files」
　　而且数据可能还在缓冲区里没落盘，close 的时候才 flush
多个流要按相反顺序关
　　先关包在外面的，try-with-resources 帮你处理这个顺序
System.out 也是个流
　　调用过 System.setOut() 之后，原来的标准输出被替换了，关的时候别关错

9. 字符流

读写文本文件时经常使用。字符流的构造方法多一个字符集参数，写文本的时候这个参数是保命的。

9.1 字符输入流（FileReader）

public static void main(String[] args) {
    //根据文件路径创建字符输入流对象
    try (
        FileReader fileReader = new FileReader("test01/src/main/java/org/example/images/file.txt");
    )//写在括号里就不用再finally里面写关闭流了，也不用写关闭管道了
    {
        char[] charBuffer = new char[1024];
        int readCount = 0;
        while ((readCount = fileReader.read(charBuffer)) != -1) {
            System.out.println(new String(charBuffer, 0, readCount));
        }
    } catch (FileNotFoundException e) {
        throw new RuntimeException(e);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

9.2 字符输出流（FileWriter）

用字符输出流进行操作后，必须调用 close 方法（或者 flush 方法）之后才能写入到文件里面，否则就是空白文件。

public static void main(String[] args) {
    //根据文件路径创建字符输出流对象
    try (
        FileWriter fileReader = new FileWriter("test01/src/main/java/org/example/images/filewrite.txt");
        FileWriter fileOneReader = new FileWriter("test01/src/main/java/org/example/images/filewrite.txt", true);//允许拼接
    )//写在括号里就不用再finally里面写关闭流了，也不用写关闭管道了
    {
        fileReader.write(97);//写一个 int，拿到的是低 16 位对应的字符
        fileReader.write('a');//按照字符写入
        fileReader.write('测');//按照字符写入
        fileReader.write("测试");
        fileReader.write("测试一个字符串", 0, 4);//从第 0 个字符开始，写 4 个字符
        char[] chars = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
        fileReader.write(chars);//按照字符数组写入
        fileReader.write(chars, 0, 5);//按照字符数组截取写入
    } catch (FileNotFoundException e) {
        throw new RuntimeException(e);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

字符流的 write(int) 写的是字符不是字节
　　write(97) 写进去的是字符 a，不是字节流里那个 97
　　它取的是 int 的低 16 位，所以别拿它写文件编码
write(String, int, int) 的长度是字符数
　　write("测试一个字符串", 0, 4) 写的是前 4 个字符，也就是「测试一个」
　　字节流那边算的是字节，两边单位不一样，别串
同一个文件开两个 Writer 是坑
　　一个覆盖一个追加，打开的瞬间覆盖的那个就把文件清空了
　　两个流写同一个文件，写到什么位置全看缓冲和关闭顺序，结果不可预期
　　要追加就只开一个带 true 的，要覆盖就只开一个不带参数的
字符集能显式指定就别省
　　new FileWriter(path, StandardCharsets.UTF_8)，JDK 10 起支持
　　不写字符集，JDK 18 前后默认值不一样，跨机器就是乱码
忘了 flush 就是空白文件
　　字符流有缓冲，数据可能在内存里没落盘
　　close() 会顺带 flush，用 try-with-resources 就没这个问题

10. 缓冲流

对原始流进行包装，能提升性能。

缓冲流性能高的原理：本身包含了 8kb 的缓冲池，假设源文件 16kb，字节数组为 1kb，原来读写需要 16 次读加 16 次写，一共 32 次；带上缓冲池后就只需要 2+2=4 次。

10.1 字节缓冲流

public static void main(String[] args) {
    //根据文件路径创建字节输入流对象
    try (
        FileInputStream fileInputStream = new FileInputStream("test01/src/main/java/org/example/images/002.png");
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream, 8192 * 2);//可以通过参数来调整缓冲池的大小
        FileOutputStream fileOutputStream = new FileOutputStream("test01/src/main/java/org/example/images/Bufffer002.png");
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream, 8192 * 2);
    )//写在括号里就不用再finally里面写关闭流了，也不用写关闭管道了
    {
        byte[] bytes = new byte[1024];
        int readCount = 0;
        while ((readCount = bufferedInputStream.read(bytes)) != -1) {
            System.out.println(readCount);
            bufferedOutputStream.write(bytes, 0, readCount);
        }
    } catch (FileNotFoundException e) {
        throw new RuntimeException(e);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

10.2 字符缓冲输入流

public static void main(String[] args) {
    //根据文件路径创建字符输入流对象
    try (
        FileReader fileInputStream = new FileReader("test01/src/main/java/org/example/images/file.txt");
        BufferedReader bufferedReader = new BufferedReader(fileInputStream);
    )//写在括号里就不用再finally里面写关闭流了，也不用写关闭管道了
    {
        //可以通过里面自带的readLine()方法来读取一行，但是不能读取文章最后一行的后面一行，文章最后一行的后面一行会返回null
        String str = "";
        while (null != (str = bufferedReader.readLine())) {
            System.out.println(str);
        }
    } catch (FileNotFoundException e) {
        throw new RuntimeException(e);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

10.3 字符缓冲输出流

public static void main(String[] args) {
    //根据文件路径创建字符输出流对象
    try (
        FileWriter fileInputStream = new FileWriter("test01/src/main/java/org/example/images/fileWrite.txt");
        BufferedWriter bufferedReader = new BufferedWriter(fileInputStream);
    )//写在括号里就不用再finally里面写关闭流了，也不用写关闭管道了
    {
        bufferedReader.write("测试一行数据");
        bufferedReader.newLine();//此方法可以自动换行
        bufferedReader.write("测试一行数据");
    } catch (FileNotFoundException e) {
        throw new RuntimeException(e);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

缓冲流是装饰器
　　它自己不读文件，接一个普通流进去，替它做批量搬运
　　所以它和被包装的流都要关，只关外层等于没关
默认缓冲池是 8192 字节
　　new BufferedInputStream(in) 就是 8 KB，可以自己传第二个参数改
readLine 是缓冲流带来的
　　FileReader 没有 readLine()，得自己按换行符切
readLine 读不到最后一行后面的那一行
　　读到文件尾它返回 null，所以判断条件是 null 不是空串
newLine 比手写 \r\n 稳
　　它按运行平台写换行符，跨平台不用自己判断
缓冲流也要 flush
　　close 会顺带 flush，用 try-with-resources 就别手动管了

11. 转换流

当程序的编码和读取文件的编码不一致时，就会出现乱码，例如程序是 utf-8 的字符集，但是 txt 文件是 GBK 字符集，这时候就需要用到转换流进行编码转换。

11.1 转换输入流

public static void main(String[] args) {
    //根据文件路径创建字节输入流对象
    try (
        FileInputStream fileInputStream = new FileInputStream("test01/src/main/java/org/example/images/hanzi.txt");
        InputStreamReader gbk = new InputStreamReader(fileInputStream, "GBK");//先转化成字节流，然后再弄成字符转换流
        BufferedReader bufferedReader = new BufferedReader(gbk);//接着再转换成缓冲流进行操作
    )//写在括号里就不用再finally里面写关闭流了，也不用写关闭管道了
    {
        //可以通过里面自带的readLine()方法来读取一行
        String str = "";
        while (null != (str = bufferedReader.readLine())) {
            System.out.println(str);
        }
    } catch (FileNotFoundException e) {
        throw new RuntimeException(e);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

11.2 转换输出流

public static void main(String[] args) {
    //根据文件路径创建字节输出流对象
    try (
        FileOutputStream fileInputStream = new FileOutputStream("test01/src/main/java/org/example/images/outputhanzi.txt");
        OutputStreamWriter gbk = new OutputStreamWriter(fileInputStream, "GBK");//先转化成字节流，然后再弄成字符转换流
        BufferedWriter bufferedReader = new BufferedWriter(gbk);//接着再转换成缓冲流进行操作
    )//写在括号里就不用再finally里面写关闭流了，也不用写关闭管道了
    {
        //这样写出来生成的txt文件就是GBK格式，直接用UTF-8看会乱码
        bufferedReader.write("  大江东去，浪淘尽，千古风流人物。");
        bufferedReader.newLine();
        bufferedReader.write("  故垒西边，人道是，三国周郎赤壁。");
    } catch (FileNotFoundException e) {
        throw new RuntimeException(e);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

写完的文件用 UTF-8 打开，IDEA 会直接提示编码不对：

转换流是字节流和字符流之间的桥
　　InputStreamReader 把字节解成字符，OutputStreamWriter 把字符编成字节
　　字符集就写在这两个类上，其他流都不用管
包装顺序不能反
　　正确顺序是 字节流 → 转换流 → 缓冲流
　　缓冲流包在转换流外面，才能一次读一行；反过来 readLine 就没有了
写出来的 GBK 文件不是错，是约定
　　文件头不带编码信息，打开的时候得知道它是 GBK
　　跨系统传文件，统一 UTF-8 才是省事的选择
用 Charset 构造器更省心
　　new InputStreamReader(in, StandardCharsets.UTF_8)，编译期定死字符集
JDK 10 之后 FileReader 也能指定字符集了
　　new FileReader(file, StandardCharsets.UTF_8)，不一定非要转换流
转换流是装饰器，别忘关
　　只关 FileInputStream 不关转换流，缓冲里的数据一样丢

12. 打印流

可以实现更加方便高效的写数据，使用方便、性能高的流。

12.1 PrintStream

public class PrintStreamClass {
    public static void main(String[] args) {
        //根据文件路径创建打印流对象
        try (
            PrintStream printStream = new PrintStream("test01/src/main/java/org/example/images/printOutStream.txt", Charset.forName("UTF-8"));//可以指定文件地址并且输出字符集编码
            FileOutputStream outputStream = new FileOutputStream("test01/src/main/java/org/example/images/printOutStream.txt");
            PrintWriter printWriter = new PrintWriter(outputStream, true, Charset.forName("UTF-8"));//可以指定文件刷新以及字符编码,字符刷新后可以在打印完就生成文件，不需要关闭流
        )//写在括号里就不用再finally里面写抛出异常了，也不用写关闭管道了
        {
            //可以使用println方法打印各种类型的数据，并且还可以自动换行，底层时全都给转换成String类型了
            printStream.println(97);
            printStream.println("a");
            printStream.println(true);
            printStream.println(98.45);
            //写单个字节
            printStream.write(97);
            //写字符串用 print
            printStream.print("a");
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

12.2 PrintWriter

public class PrintWriterClass {
    public static void main(String[] args) {
        //根据文件路径创建打印流对象
        try (
            PrintWriter printWriter = new PrintWriter(new FileOutputStream("test01/src/main/java/org/example/images/printOutStream.txt"), true, Charset.forName("UTF-8"));//可以指定文件刷新以及字符编码
        )//写在括号里就不用再finally里面写抛出异常了，也不用写关闭管道了
        {
            //可以使用println方法打印各种类型的数据，并且还可以自动换行，底层时全都给转换成String类型了
            printWriter.println(97);
            printWriter.println("a");
            printWriter.println(true);
            printWriter.println(98.45);
            //写一个 int，拿到的是低 16 位对应的字符
            printWriter.write(97);
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

12.3 日志输出

System.out.println() 其实就是打印流，System.out 相当于是获取控制台的输出流。可以通过指定日志输出流的地址，把日志输出到指定文件中。

public static void main(String[] args) {
    System.out.println("床前明月光");
    System.out.println("疑是地上霜");
    try (PrintStream printStream = new PrintStream("test01/src/main/java/org/example/images/printbaocun.txt", Charset.forName("UTF-8"));){
        //通过new一个输出流，把系统的日志输出到指定文件中，前两句诗输出在控制台里面，后两句输出在文件printbaocun中
        System.setOut(printStream);
        System.out.println("举头望明月");
        System.out.println("低头思故乡");
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

PrintStream.write(String) 是 private，编译不过
　　公开的 write 只有 write(int)、write(byte[])、write(byte[], int, int)
　　写字符串用 print() 或 println()
PrintStream 吞异常
　　它内部把 IOException 记在一个 trouble 标志上，不往外抛
　　要感知写失败，得调 checkError()，或者用 PrintWriter
PrintWriter 有 checkError 和 flush
　　它不吞异常，是真正做字符输出的那个，写文本优先用它
自动刷新是按行来的
　　构造器第二个参数传 true，碰到换行或者调用 flush 才落盘
　　不自动刷新的话，程序异常退出，缓冲区里的日志就丢了
System.setOut 换的是全局标准输出
　　换完整个 JVM 的 System.out 都变了，测试里换了记得换回来
生产环境别用 System.out 记日志
　　用 logback 或 log4j2，能分级、能落盘能轮转

13. 数据流

可以把打印的数据以及他的类型一并保存起来，在文件中看起来是乱码，但是读出来就正常了。

public static void main(String[] args) {
    try (
        FileOutputStream fileOutputStream = new FileOutputStream("test01/src/main/java/org/example/images/dataoutstream.txt");
        DataOutputStream dos = new DataOutputStream(fileOutputStream);
        FileInputStream fileInputStream = new FileInputStream("test01/src/main/java/org/example/images/dataoutstream.txt");
        DataInputStream dis = new DataInputStream(fileInputStream);
    ){
        //连带着内容和类型一块存进去，存进去后文件是乱码的，但是可以根据类型再读出来
        dos.writeInt(97);
        dos.writeDouble(97.5566);
        dos.writeUTF("测试字符串");
        dos.writeBoolean(false);
        //根据顺序读内容，一定要对应起来，否则就会出问题
        System.out.println(dis.readInt());
        System.out.println(dis.readDouble());
        System.out.println(dis.readUTF());
        System.out.println(dis.readBoolean());
    } catch (Exception e) {
        e.printStackTrace();
    }
}

数据流是带类型的字节流
　　writeInt 写 4 字节，writeDouble 写 8 字节，writeBoolean 写 1 字节
　　读的时候用对应的 read 方法，类型自动还原
写和读的顺序必须一一对应
　　写的时候先 writeInt 再 writeUTF，读就得先 readInt 再 readUTF
　　顺序错一个，readUTF 会把长度字段当成内容读出来，后面全串位
writeUTF 有 2 字节长度前缀
　　它用的是 modified UTF-8，每个 BMP 字符 1 到 3 字节
　　实测「测试字符串」5 个字写 17 字节，整份文件 30 字节
DataOutputStream 是装饰器
　　它包在 FileOutputStream 外面，两个都得关
别拿它写给人看的文件
　　存进去的是二进制，记事本打开是乱码，要存文本就用字符流

14. 序列化

要把对象类进行网络传输时需要进行序列化，拿到对象后再进行反序列化。因为网络传输都是二进制，对象是不能直接传输的。

序列化可以使用原生的方法，如下用流进行操作（必须要在类上面实现 Serializable），也可以用 JSON 等方式。

14.1 序列化

把 java 对象写到文件中去：

public static void main(String[] args) {
    User user = new User();
    user.setName("张三");
    user.setAge(18);
    user.setAddress("北京市");
    user.setPhone("123456789");
    try (
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("test01/src/main/java/org/example/images/ObjectStreamClas.txt"));
    ){
        //此处使用User类必须经过序列化，否则就无法变成对象存储
        objectOutputStream.writeObject(user);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

14.2 反序列化

把文件读回 java 对象中来：

public static void main(String[] args) {
    try (
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("test01/src/main/java/org/example/images/ObjectStreamClas.txt"));
    ){
        //此处使用User类必须经过序列化，否则就无法变成对象存储
        User user = (User) objectInputStream.readObject();
        System.out.println(user);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

被序列化的类长这样，Serializable 是个空接口，声明了就能被序列化：

import java.io.Serializable;

public class User implements Serializable {
    private static final long serialVersionUID = 1L;

    private String name;
    private int age;
    private String address;
    private String phone;

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String getAddress() { return address; }
    public void setAddress(String address) { this.address = address; }
    public String getPhone() { return phone; }
    public void setPhone(String phone) { this.phone = phone; }

    @Override
    public String toString() {
        return "User{name='" + name + "', age=" + age + ", address='" + address + "', phone='" + phone + "'}";
    }
}

类必须 implements Serializable
　　没实现就抛 NotSerializableException，编译期不报错，运行时才炸
serialVersionUID 写死一个
　　它是指纹，类一改它就可能对不上，反序列化直接抛 InvalidClassException
transient 修饰的字段不进字节流
　　读回来是默认值，密码、临时 token 这类别指望它带过去
static 字段本来就不参与
　　它属于类不属于对象，序列化管不着
反序列化不可信数据等于开了个洞
　　读一个来路不明的文件，readObject() 会按文件里的描述去实例化类
　　JDK 9 起有 ObjectInputFilter 做类名白名单
跨服务传对象优先 JSON 或 Protobuf
　　可读、跨语言、不挑 JDK 版本，原生序列化只适合自己存自己读

15. IO 框架

15.1 Commons-IO

Apache Commons IO 是给 IO 写的一堆工具类，最新是 2.22.0，最低要 Java 8。

<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.22.0</version>
</dependency>

import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;

public class CommonsIoDemo {
    public static void main(String[] args) throws Exception {
        File src = new File("test01/src/main/resources/images/002.png");
        File dest = new File("test01/src/main/resources/images/copy002.png");

        //一行拷贝整个文件，不用自己写循环
        FileUtils.copyFile(src, dest);

        //读文本，字符集显式指定
        String text = FileUtils.readFileToString(new File("notes.txt"), StandardCharsets.UTF_8);
        System.out.println(text);

        //流之间倒数据
        try (InputStream in = new FileInputStream(src);
             OutputStream out = new FileOutputStream(dest)) {
            IOUtils.copy(in, out);
        }
    }
}

15.2 Hutool

Hutool 是国产的 Java 工具库，5.8 系列是当前稳定线，最新 5.8.48。

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.48</version>
</dependency>

import cn.hutool.core.io.FileUtil;
import cn.hutool.core.io.IoUtil;
import java.io.File;
import java.io.FileInputStream;
import java.nio.charset.StandardCharsets;

public class HutoolIoDemo {
    public static void main(String[] args) throws Exception {
        //读字符串，默认 UTF-8
        String content = FileUtil.readUtf8String("notes.txt");
        System.out.println(content);

        //一行拷贝，第三个参数是「目标已存在时是否覆盖」
        FileUtil.copy("src.txt", "dest.txt", true);

        //目录操作
        File[] files = FileUtil.ls("D:\\data");
        FileUtil.mkdir("D:\\data\\sub");

        //流之间倒数据
        byte[] bytes = IoUtil.readBytes(new FileInputStream("notes.txt"));
    }
}

Commons-IO 和 Hutool 干的是同一件事
　　一个 Apache 官方，一个国产全家桶，方法名不一样，思路一样
FileUtils 最大的价值是删文件夹和拷文件夹
　　FileUtils.deleteDirectory(dir) 递归删，自己写要十几行
工具类解决的是「重复代码」，不是「理解流」
　　面试问的是原理，工具库解决的是效率，两回事
别让框架遮住 API
　　用 FileUtils 之前，至少手写过一次原始流，出问题才知道往哪查
新项目优先看 NIO
　　Files.copy、Files.readAllLines、Files.walk 一行顶一段，而且没有 checked exception
框架是兜底不是起点
　　先搞懂管道、缓冲、编码这三件事，框架只是把它们包了个壳

💡 补充几个容易忽略的：
JDK 18 起默认字符集才是 UTF-8
　　JDK 17 及更早是平台默认，中文 Windows 上是 GBK，JEP 400 改的
　　所以「不写字符集」这件事，跨版本结果不一样
相对路径的基准是工作目录
　　不是项目根，也不是类所在目录，IDEA 里是模块目录，命令行里是启动命令的目录
　　打包成 jar 之后工作目录更容易变，配置和资源别靠相对路径找
File 是老 API，新代码优先 Path
　　Path 和 Files 组合起来一行能顶十行，而且不抛受检异常
大文件别整个读进内存
　　流式读 + 缓冲流 + try-with-resources 是三件套，JDK 9 之后还有 transferTo 可以偷懒
流是单向的，读写要开两个
　　同一个流不能既读又写，随机读写用 RandomAccessFile
先想清楚字节还是字符
　　这一步定了，编码的事就定了，文本用字符流，二进制用字节流
官方文档和教程的定位不一样
　　官方文档按主题排，适合查细节；菜鸟教程的 Java 目录按学习顺序排，适合当路线图
　　两边对着看，学的顺序和查的效率都能兼顾

🔥 一句话总结：File 只管路径和元数据，内容得靠流；流按方向分输入输出、按最小单位分字节字符，字节流不管编码，字符流才管；同一个字 UTF-8 三个字节 GBK 两个字节，JDK 18 起默认才是 UTF-8，永远显式写字符集；read() 单字节慢得离谱，read(byte[]) 要按实际长度截断，桶里的残留和结尾的 -1 是两个经典坑；写的时候默认覆盖不是追加，截取长度算的是字节；流用完必须关，Java 7 之后一律用 try-with-resources；缓冲流靠 8KB 缓冲池把 32 次读写压到 4 次；转换流的字符集就写在 InputStreamReader 和 OutputStreamWriter 上，包装顺序是字节流→转换流→缓冲流；PrintStream.write(String) 是 private 编译不过，它还吞异常，写文本优先 PrintWriter；数据流带着类型一起存，读写顺序必须一一对应；序列化要求类 implements Serializable，serialVersionUID 写死，transient 字段不参与，反序列化不可信数据就是漏洞，跨服务传对象用 JSON；Commons-IO 2.22 和 Hutool 5.8 是兜底不是起点，新代码优先 Path 和 Files。