关于 java：5. Java IO 与文件操作

一、File 类（读取文件属性）

1.1 `java.io.File` 类概述

File 是 Java IO 中的核心类，用于表示文件或目录的路径名。
它是一个抽象路径名，可以表示实际存在或不存在的文件/文件夹。
File 类提供了创建、删除、重命名、判断属性、获取信息、遍历目录等功能。

注意：File 代表的是路径，而不是文件内容；真正的读写要通过流（InputStream、Reader 等）完成。

1.2 构造方法（路径的定义）

// 相对路径
File file1 = new File("example.txt");

// 绝对路径（Windows 示例）
File file2 = new File("C:\\Users\\admin\\Desktop\\test.txt");

// 父路径 + 子路径组合
File dir = new File("C:\\Users\\admin");
File file3 = new File(dir, "data.txt");

1.3 常用方法分类

1）判断文件或目录属性

方法	说明	示例
`exists()`	文件/目录是否存在	`file.exists()`
`isFile()`	是否是文件	`file.isFile()`
`isDirectory()`	是否是目录	`file.isDirectory()`
`canRead()`	是否可读	`file.canRead()`
`canWrite()`	是否可写	`file.canWrite()`
`canExecute()`	是否可执行	`file.canExecute()`

2）获取路径信息

方法	说明
`getName()`	获取文件名或目录名
`getPath()`	获取路径（构造时传的）
`getAbsolutePath()`	获取绝对路径
`getParent()`	获取父路径字符串
`getParentFile()`	获取父路径的 File 对象

3）文件/目录信息

方法	说明
`length()`	文件大小（字节），目录为0
`lastModified()`	最后修改时间（时间戳，单位毫秒）
`isHidden()`	是否是隐藏文件

4）创建/删除文件或目录

方法	说明
`createNewFile()`	创建新文件（若存在则不创建）
`mkdir()`	创建单级目录
`mkdirs()`	创建多级目录
`delete()`	删除文件或空目录

5）遍历目录

方法	返回类型	说明
`list()`	`String[]`	获取子文件/目录名
`listFiles()`	`File[]`	获取子文件/目录对象
`list(FilenameFilter)`	`String[]`	带过滤器返回文件名
`listFiles(FileFilter)`	`File[]`	带过滤器返回 File 对象

1.4 常用案例演示

1）判断文件是否存在，获取基本属性

File file = new File("test.txt");

if (file.exists()) {
    System.out.println("文件存在");
    System.out.println("是文件？" + file.isFile());
    System.out.println("是目录？" + file.isDirectory());
    System.out.println("大小：" + file.length() + " 字节");
    System.out.println("最后修改时间：" + new Date(file.lastModified()));
} else {
    System.out.println("文件不存在");
}

2）获取路径信息

File file = new File("data.txt");

System.out.println("名称：" + file.getName());
System.out.println("路径：" + file.getPath());
System.out.println("绝对路径：" + file.getAbsolutePath());
System.out.println("父路径：" + file.getParent());

3）遍历目录

File dir = new File("C:\\Users\\admin");

if (dir.isDirectory()) {
    File[] files = dir.listFiles();
    for (File f : files) {
        System.out.println((f.isDirectory() ? "[目录]" : "[文件]") + " " + f.getName());
    }
}

4）创建和删除文件/目录

// 创建文件
File file = new File("newFile.txt");
if (!file.exists()) {
    file.createNewFile();
}

// 创建目录
File dir = new File("newFolder");
if (!dir.exists()) {
    dir.mkdir(); // 创建单级目录
}

// 删除文件
file.delete();

1.5 文件过滤器使用示例

只列出 .txt 文件

File dir = new File("C:\\Users\\admin");  // 创建一个 File 对象，表示目录 C:\Users\admin

File[] txtFiles = dir.listFiles(new FilenameFilter() {  // 获取该目录下所有扩展名为 .txt 的文件
    public boolean accept(File dir, String name) {       // 实现 FilenameFilter 接口的 accept 方法
        return name.endsWith(".txt");                    // 只有以 .txt 结尾的文件名才会被接受
    }
});

for (File f : txtFiles) {                  // 遍历所有筛选出的 .txt 文件
    System.out.println(f.getName());       // 输出每个文件的文件名（不含路径）
}

1.6 注意事项

File 类不会检查文件内容或权限，只是文件系统路径的抽象。
调用 delete() 删除的是文件或空目录，不能直接删除非空目录。
所有路径都建议使用双反斜杠 \\ 或使用 File.separator 来兼容跨平台。

1.7 小结

类型	推荐用法
判断是否存在	`file.exists()`
判断文件/目录	`isFile()` / `isDirectory()`
获取大小与时间	`length()` / `lastModified()`
遍历目录	`listFiles()`
创建目录	`mkdir()` / `mkdirs()`
创建文件	`createNewFile()`
删除文件	`delete()`

二、字节流：InputStream、OutputStream

2.1 字节流概述

Java 中的字节流用于处理 二进制数据，是 java.io 包中最基础的 IO 操作类型。

输入（读）方向	输出（写）方向
`InputStream`（抽象类）	`OutputStream`（抽象类）

字节流可以读取/写入所有类型的数据，如：图片、音频、视频、PDF、Word、压缩包等。

2.2 字节流的类结构（继承体系）

InputStream（抽象类）        ← 读取数据（byte）
 ├── FileInputStream       ← 从文件中读取
 ├── BufferedInputStream   ← 加缓冲，效率高
 └── ByteArrayInputStream  ← 从内存 byte[] 中读取

OutputStream（抽象类）       ← 写出数据（byte）
 ├── FileOutputStream      ← 向文件写入
 ├── BufferedOutputStream  ← 加缓冲，效率高
 └── ByteArrayOutputStream ← 写入到内存 byte[]

2.3 InputStream 与 OutputStream 常用方法

InputStream 常用方法

方法	说明
`int read()`	每次读取一个字节（0~255）
`int read(byte[] b)`	读取多个字节到数组中
`int read(byte[] b, int off, int len)`	从 off 开始读 len 个字节
`void close()`	关闭流，释放资源

OutputStream 常用方法

方法	说明
`void write(int b)`	写一个字节
`void write(byte[] b)`	写多个字节
`void write(byte[] b, int off, int len)`	写部分字节
`void flush()`	刷新缓冲区
`void close()`	关闭流，释放资源

2.4 常用子类详解

1）FileInputStream / FileOutputStream

用于从文件读取字节 或 写入字节到文件

FileInputStream fis = new FileInputStream("a.jpg");
FileOutputStream fos = new FileOutputStream("b.jpg");

int b;
while ((b = fis.read()) != -1) {
    fos.write(b); // 每次读写一个字节（效率较低）
}

fis.close();
fos.close();

2）使用缓冲流提高效率：BufferedInputStream / BufferedOutputStream

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.jpg"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.jpg"));

byte[] buffer = new byte[1024];
int len;
while ((len = bis.read(buffer)) != -1) {
    bos.write(buffer, 0, len);
}

bis.close();
bos.close();

优点：缓冲区减少了系统调用次数，性能显著提升。

3）ByteArrayInputStream / ByteArrayOutputStream

用于内存中读写（非文件）
常用于网络传输、临时缓存处理、加密转换等场景

byte[] data = {65, 66, 67}; // ABC
ByteArrayInputStream bais = new ByteArrayInputStream(data);
int b;
while ((b = bais.read()) != -1) {
    System.out.print((char) b); // 输出 ABC
}
bais.close();

ByteArrayOutputStream baos = new ByteArrayOutputStream();
baos.write(65);  // A
baos.write(66);  // B
baos.write(67);  // C

byte[] result = baos.toByteArray();  // 获取写入结果
System.out.println(Arrays.toString(result)); // [65, 66, 67]

2.5 文件复制完整示例（推荐写法）

public static void copyFile(String source, String target) throws IOException {
    try (
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(source));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(target));
    ) {
        byte[] buffer = new byte[4096];
        int len;
        while ((len = bis.read(buffer)) != -1) {
            bos.write(buffer, 0, len);
        }
    }
}

2.6 InputStream / OutputStream 应用场景

场景	使用
图片、视频、音频处理	`FileInputStream` + `FileOutputStream`
网络数据流接收处理	`InputStream` / `OutputStream`（Socket等）
二进制数据处理（如 Base64）	`ByteArrayStream`
高性能大文件处理	加上 `BufferedXXXStream`
文件加密、压缩传输	配合加密类、GZIP、ZipStream 等使用

2.7 常见错误与注意事项

使用完流必须 close()（建议使用 try-with-resources 自动关闭）
不推荐逐字节读写，推荐使用 byte[] 缓冲区
字节流适合处理任意文件类型（而字符流只适合文本）
read() 返回的是 int，范围 0~255，-1 表示 EOF（读取完毕）

2.8 小结

特性	InputStream / OutputStream
单位	字节（byte）
支持数据	所有类型（文本、图片、音频等）
性能	`Buffered` 子类性能更高
常用用途	复制文件、网络传输、压缩、加密等

三、字符流：Reader、Writer

3.1 什么是字符流？

字符流用于处理文本文件（字符型数据），如 .txt、.java 等。
每次读写一个或多个字符（char），而不是字节。
基于 Unicode 字符集设计，自动处理字符编码。

适用于只包含字符的文件，尤其是中文、英文、符号等文本内容。

3.2 类结构图

Reader（抽象类）        ← 读取字符
 ├── FileReader        ← 从文件读取字符
 ├── BufferedReader    ← 带缓冲，高效读取
 └── InputStreamReader ← 字节流转字符流（支持编码）

Writer（抽象类）        ← 写入字符
 ├── FileWriter        ← 向文件写入字符
 ├── BufferedWriter    ← 带缓冲，高效写入
 └── OutputStreamWriter← 字符流转字节流（支持编码）

3.3 常用方法

Reader 类常用方法：

方法	说明
`int read()`	读取一个字符（返回 0~65535）或 -1 表示读完
`int read(char[] cbuf)`	读取多个字符到字符数组
`int read(char[] cbuf, int offset, int len)`	读取指定长度
`void close()`	关闭流

Writer 类常用方法：

方法	说明
`void write(int c)`	写入单个字符
`void write(char[] cbuf)`	写入字符数组
`void write(String str)`	写入字符串
`void flush()`	刷新缓冲区
`void close()`	关闭流

3.4 常用子类与示例

1）FileReader / FileWriter（基础文件读写）

// 读取文本文件
FileReader reader = new FileReader("demo.txt");
int ch;
while ((ch = reader.read()) != -1) {
    System.out.print((char) ch);
}
reader.close();

// 写入文本文件
FileWriter writer = new FileWriter("demo.txt");
writer.write("你好，世界！");
writer.close();

2）使用 BufferedReader / BufferedWriter（推荐！更高效）

// 逐行读取文本文件
BufferedReader br = new BufferedReader(new FileReader("demo.txt"));
String line;
while ((line = br.readLine()) != null) {
    System.out.println(line);
}
br.close();

// 写入文本，带换行
BufferedWriter bw = new BufferedWriter(new FileWriter("demo.txt"));
bw.write("第一行");
bw.newLine(); // 换行
bw.write("第二行");
bw.close();

3）InputStreamReader / OutputStreamWriter（支持编码）

// 指定编码读取（如 GBK）
InputStreamReader isr = new InputStreamReader(
    new FileInputStream("gbk.txt"), "GBK"
);
BufferedReader br = new BufferedReader(isr);
String line;
while ((line = br.readLine()) != null) {
    System.out.println(line);
}
br.close();

// 指定编码写入（如 UTF-8）
OutputStreamWriter osw = new OutputStreamWriter(
    new FileOutputStream("utf8.txt"), "UTF-8"
);
BufferedWriter bw = new BufferedWriter(osw);
bw.write("UTF-8 编码内容");
bw.close();

3.5 字符流 vs 字节流

对比点	字节流（InputStream/OutputStream）	字符流（Reader/Writer）
数据单位	byte（字节）	char（字符）
处理内容	任意数据（包括图片、视频）	文本数据（如 .txt）
编码处理	不处理编码	会自动进行字符编码转换
推荐用途	二进制文件	纯文本文件

3.6 注意事项

字符流默认使用平台编码，可能导致跨平台乱码（建议手动指定编码）。
如果处理的是二进制数据（图片、音频等），不要使用字符流！
一般搭配缓冲流 BufferedReader / BufferedWriter 使用，效率高且功能强。
推荐使用 try-with-resources 自动关闭流。

3.7 实战总结（推荐组合）

目标	推荐组合
读文本文件	`BufferedReader br = new BufferedReader(new FileReader(...))`
写文本文件	`BufferedWriter bw = new BufferedWriter(new FileWriter(...))`
读带编码文本	`InputStreamReader + BufferedReader`
写带编码文本	`OutputStreamWriter + BufferedWriter`

四、缓冲流：BufferedReader、BufferedWriter

4.1 什么是缓冲流？

缓冲流是对原始 Reader / Writer 的包装增强，通过内置缓冲区减少频繁的 I/O 访问，提高读写效率。
它不会直接操作文件，而是将数据暂存在内存的缓冲区中，等到积累一定数量后一次性读写。

类名	作用
`BufferedReader`	提高字符读取效率，支持按行读取
`BufferedWriter`	提高字符写入效率，支持缓冲写入与换行

4.2 使用场景

需求	推荐缓冲流
读取大文本文件	`BufferedReader`
写入大量文本	`BufferedWriter`
按行处理文本（如日志、配置）	`BufferedReader.readLine()`
想减少磁盘访问次数	使用缓冲流

4.3 BufferedReader / BufferedWriter 类结构

BufferedReader br = new BufferedReader(new FileReader("test.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("test.txt"));

它们都是装饰器类（装饰设计模式），作用是增强基本流。

4.4 BufferedReader 使用详解

构造方法：

BufferedReader br = new BufferedReader(Reader in);
BufferedReader br = new BufferedReader(Reader in, int bufferSize); // 可设置缓冲大小

常用方法：

方法	说明
`String readLine()`	读取一行，返回 null 表示读完
`int read()`	读取单个字符
`int read(char[] cbuf, int off, int len)`	读取多个字符
`void close()`	关闭流

示例：读取文本文件的每一行

BufferedReader br = new BufferedReader(new FileReader("test.txt"));
String line;
while ((line = br.readLine()) != null) {
    System.out.println(line);
}
br.close();

4.5 BufferedWriter 使用详解

构造方法：

BufferedWriter bw = new BufferedWriter(Writer out);
BufferedWriter bw = new BufferedWriter(Writer out, int bufferSize); // 可设置缓冲大小

常用方法：

方法	说明
`void write(String s)`	写入字符串
`void newLine()`	写入一个换行符（平台独立）
`void flush()`	强制将缓冲区内容写入目标
`void close()`	关闭流并刷新缓冲区

示例：写入文件并换行

BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"));
bw.write("第一行");
bw.newLine(); // 换行
bw.write("第二行");
bw.close();

4.6 缓冲流的原理（简略）

以 BufferedReader 为例：

private char cb[];    // 字符缓冲区
private int nChars, nextChar; // 当前缓冲区大小 & 当前读取索引

int read() {
    if (nextChar >= nChars) {
        fill(); // 一次性从底层流读一批数据到 cb[]
    }
    return cb[nextChar++];
}

这样一来，磁盘读取次数就减少了，大大提升性能。

4.7 文件复制示例（纯文本，字符流方式）

public static void copyTextFile(String src, String dest) throws IOException {
    try (
        BufferedReader br = new BufferedReader(new FileReader(src));
        BufferedWriter bw = new BufferedWriter(new FileWriter(dest))
    ) {
        String line;
        while ((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine(); // 保留原来的换行
        }
    }
}

4.8 使用技巧 & 注意事项

注意点	说明
推荐搭配 try-with-resources	自动关闭流
必须 `flush()` 或 `close()`	否则可能内容没真正写入文件
只适用于纯文本文件	图片、视频请使用字节流
推荐使用缓冲流而非原始 FileReader/FileWriter	性能更高、功能更强

4.9 小结

对比项	BufferedReader	BufferedWriter
功能	提高字符读取效率，支持逐行读取	提高字符写入效率，支持换行
内部缓冲	有，默认 8192 字符	有，默认 8192 字符
适合	文本读取	文本写入
搭配	`FileReader`、`InputStreamReader`	`FileWriter`、`OutputStreamWriter`

五、文件读写、目录遍历、复制、删除

5.1 文件读写

1）写文件（使用 BufferedWriter）

BufferedWriter writer = new BufferedWriter(new FileWriter("example.txt"));
writer.write("Hello, world!");
writer.newLine();
writer.write("第二行内容");
writer.close();

2）读文件（使用 BufferedReader）

BufferedReader reader = new BufferedReader(new FileReader("example.txt"));
String line;
while ((line = reader.readLine()) != null) {
    System.out.println(line);
}
reader.close();

推荐使用缓冲流：高效、支持按行读取写入。

5.2 目录遍历（使用 `File` 类）

遍历指定目录下所有文件和文件夹：

File dir = new File("C:/myfolder");
File[] files = dir.listFiles(); // 仅一层，不递归

for (File file : files) {
    if (file.isFile()) {
        System.out.println("文件: " + file.getName());
    } else if (file.isDirectory()) {
        System.out.println("目录: " + file.getName());
    }
}

递归遍历所有子目录和文件：

public static void listAllFiles(File dir) {
    File[] files = dir.listFiles();
    if (files == null) return;
    for (File file : files) {
        if (file.isFile()) {
            System.out.println("文件: " + file.getAbsolutePath());
        } else if (file.isDirectory()) {
            System.out.println("目录: " + file.getAbsolutePath());
            listAllFiles(file); // 递归遍历
        }
    }
}

5.3 文件复制

1）字符流复制（用于文本文件）

public static void copyTextFile(String srcPath, String destPath) throws IOException {
    try (
        BufferedReader reader = new BufferedReader(new FileReader(srcPath));
        BufferedWriter writer = new BufferedWriter(new FileWriter(destPath))
    ) {
        String line;
        while ((line = reader.readLine()) != null) {
            writer.write(line);
            writer.newLine();
        }
    }
}

2）字节流复制（用于图片、音频、视频等二进制文件）

public static void copyBinaryFile(String srcPath, String destPath) throws IOException {
    try (
        FileInputStream in = new FileInputStream(srcPath);
        FileOutputStream out = new FileOutputStream(destPath)
    ) {
        byte[] buffer = new byte[4096];
        int len;
        while ((len = in.read(buffer)) != -1) {
            out.write(buffer, 0, len);
        }
    }
}

5.4 删除文件与目录

1）删除单个文件

File file = new File("example.txt");
if (file.exists()) {
    boolean deleted = file.delete();
    System.out.println(deleted ? "删除成功" : "删除失败");
}

2）删除空目录

File dir = new File("emptyDir");
if (dir.isDirectory()) {
    dir.delete(); // 仅能删除空目录
}

3）递归删除目录及其所有内容（包括子文件夹）

public static void deleteDir(File dir) {
    File[] files = dir.listFiles();
    if (files != null) {
        for (File file : files) {
            if (file.isDirectory()) {
                deleteDir(file); // 递归删除子目录
            } else {
                file.delete(); // 删除文件
            }
        }
    }
    dir.delete(); // 删除目录本身
}

5.5 判断文件或目录属性

File f = new File("test.txt");
System.out.println("是否存在: " + f.exists());
System.out.println("是否为文件: " + f.isFile());
System.out.println("是否为目录: " + f.isDirectory());
System.out.println("绝对路径: " + f.getAbsolutePath());
System.out.println("父路径: " + f.getParent());
System.out.println("文件名: " + f.getName());
System.out.println("文件长度: " + f.length()); // 字节数

5.6 常见坑点提示

问题	原因与解决
中文乱码	指定编码 `new OutputStreamWriter(..., "UTF-8")`
无法删除目录	必须先删除其中的所有文件和子目录
写入内容未落盘	要调用 `flush()` 或 `close()`
多层目录创建失败	用 `mkdirs()` 而不是 `mkdir()`
文件不存在	注意判断 `file.exists()`，必要时 `createNewFile()`

六、文件编码问题（UTF-8 / GBK）

6.1 文件乱码的根源

编码问题通常发生在文件读写中字符与字节的转换阶段，例如：

Windows 系统默认编码为 GBK；
Linux/IDEA 默认编码为 UTF-8；
一个文件写入时用了 GBK，读取时却用 UTF-8，会导致乱码（或直接抛出异常）。

6.2 常见编码格式

编码	描述
UTF-8	国际标准编码，支持所有字符，推荐使用
GBK	中国大陆常见编码，兼容 GB2312，双字节表示中文
ISO-8859-1	单字节编码，不支持中文（Java 默认处理异常时有时会退回这个）

6.3 编码影响的地方

环节	是否涉及编码
写文件（Writer）	需要指定编码
读文件（Reader）	需要指定编码
文件名、路径	不受影响（现代 JVM 支持 UTF-8 文件名）

6.4 如何在 Java 中处理编码

1）正确的写法（推荐）

使用 InputStreamReader / OutputStreamWriter 并指定编码：

读取 GBK 文件

BufferedReader reader = new BufferedReader(
    new InputStreamReader(new FileInputStream("gbk_file.txt"), "GBK")
);

写入 UTF-8 文件

BufferedWriter writer = new BufferedWriter(
    new OutputStreamWriter(new FileOutputStream("utf8_file.txt"), "UTF-8")
);

2）错误写法（容易乱码）

// 不指定编码，使用平台默认编码（如 Windows 是 GBK，Linux 是 UTF-8）
BufferedReader reader = new BufferedReader(new FileReader("some_file.txt"));

6.5 验证文件编码的小技巧

Java代码检测 UTF-8 vs GBK

public static void detectEncoding(String filePath) throws IOException {
    FileInputStream fis = new FileInputStream(filePath);
    byte[] bom = new byte[3];
    fis.read(bom);
    if ((bom[0] & 0xFF) == 0xEF && (bom[1] & 0xFF) == 0xBB && (bom[2] & 0xFF) == 0xBF) {
        System.out.println("UTF-8 with BOM");
    } else {
        System.out.println("可能是 GBK 或 UTF-8 无 BOM");
    }
    fis.close();
}

更准确的方法需要用第三方库如 juniversalchardet。

6.6 示例：跨平台读写防乱码

写入一个 UTF-8 文本文件

BufferedWriter writer = new BufferedWriter(
    new OutputStreamWriter(new FileOutputStream("hello_utf8.txt"), StandardCharsets.UTF_8)
);
writer.write("你好，世界！");
writer.close();

在 GBK 系统下读取 UTF-8 文件（错例，可能乱码）

// 错误示范：不指定编码，默认 GBK
BufferedReader reader = new BufferedReader(new FileReader("hello_utf8.txt"));

正确：读取时也指定 UTF-8

BufferedReader reader = new BufferedReader(
    new InputStreamReader(new FileInputStream("hello_utf8.txt"), "UTF-8")
);

6.7 编码问题的常见坑与解决方案

问题	原因	解决方案
文本乱码	读写编码不一致	统一使用 UTF-8，并显式指定
控制台乱码	IDEA 或终端编码设置错误	修改 IDE 编码设置为 UTF-8
写入中文异常	没指定编码，退回 ISO-8859-1	指定 `OutputStreamWriter(..., "UTF-8")`
显示多个问号 `???`	控制台不支持字符集	替换控制台字体或编码

6.8 编码实战建议

始终统一编码（推荐 UTF-8，无 BOM）；
所有读写都显式指定编码；
团队项目设定统一编码规范（IDE、Git、文件）；
使用 Notepad++、IDEA 或 Sublime 检查和转换文件编码。

6.9 实战工具方法封装

public static List<String> readFile(String path, String charset) throws IOException {
    try (BufferedReader reader = new BufferedReader(                   // 创建缓冲字符输入流，用于高效读取文本
        new InputStreamReader(new FileInputStream(path), charset))) { // 指定字符编码读取文件内容
        List<String> lines = new ArrayList<>();                        // 用于存储读取到的每一行文本
        String line;                                                   // 临时变量，存储每次读取的一行
        while ((line = reader.readLine()) != null) {                   // 持续读取直到文件末尾（readLine 读到 null）
            lines.add(line);                                           // 把每行内容加入列表
        }
        return lines;                                                  // 返回所有读取到的行
    }                                                                  // try-with-resources 自动关闭 reader 流
}


public static void writeFile(String path, List<String> lines, String charset) throws IOException {
    try (BufferedWriter writer = new BufferedWriter(                   // 创建缓冲字符输出流，用于高效写入文本
        new OutputStreamWriter(new FileOutputStream(path), charset))) { // 指定字符编码写入文件
        for (String line : lines) {                                    // 遍历列表中的每一行内容
            writer.write(line);                                        // 写入该行内容（不自动换行）
            writer.newLine();                                          // 写入一个换行符，等价于 println()
        }
    }                                                                  // try-with-resources 自动关闭 writer 流
}