Java文件操作：从基础IO到NIO.2实战指南

1. Java文件操作基础概念

在Java开发中，文件操作是最基础也是最重要的技能之一。无论是处理配置文件、日志记录还是数据持久化，都离不开对文件的读写操作。Java提供了丰富的API来支持各种文件操作需求，从基础的java.io包到更现代的java.nio包，开发者可以根据具体场景选择合适的工具。

文件操作的核心在于理解数据如何在内存和存储设备之间流动。当我们谈论"文本文件"时，通常指的是以纯文本格式存储的文件，内容由可打印字符组成，可以用普通文本编辑器直接查看和编辑。与之相对的是二进制文件，如图片、音频等，需要特定程序才能解析。

Java处理文本文件的主要方式有两种：基于字符的I/O流和基于字节的I/O流。对于文本文件，我们通常使用字符流(Reader/Writer)，因为它们能正确处理字符编码问题；而对于二进制文件，则需要使用字节流(InputStream/OutputStream)。

注意：在Java中处理文本文件时，必须特别注意字符编码问题。如果不显式指定编码，Java会使用平台默认编码，这可能导致在不同操作系统上运行时出现乱码问题。

2. 文本文件读写实现详解

2.1 使用FileReader和FileWriter

FileReader和FileWriter是Java中最基础的文本文件读写类。它们继承自InputStreamReader和OutputStreamWriter，使用平台默认编码处理字符流。

java复制// 写入文本文件示例
try (FileWriter writer = new FileWriter("example.txt")) {
    writer.write("Hello, Java文件操作!\n");
    writer.write("这是第二行内容");
} catch (IOException e) {
    e.printStackTrace();
}

// 读取文本文件示例
try (FileReader reader = new FileReader("example.txt")) {
    int character;
    while ((character = reader.read()) != -1) {
        System.out.print((char) character);
    }
} catch (IOException e) {
    e.printStackTrace();
}

这种方式的优点是简单直接，但缺点也很明显：没有缓冲机制，每次读写都是直接操作磁盘，效率较低；而且使用平台默认编码，跨平台时可能出问题。

2.2 使用BufferedReader和BufferedWriter

为了提高效率，通常会配合使用缓冲流：

java复制// 高效写入文本文件
try (BufferedWriter writer = new BufferedWriter(new FileWriter("buffered.txt"))) {
    writer.write("使用缓冲流提高效率");
    writer.newLine();  // 换行
    writer.write("第二行内容");
} catch (IOException e) {
    e.printStackTrace();
}

// 高效读取文本文件
try (BufferedReader reader = new BufferedReader(new FileReader("buffered.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

BufferedReader的readLine()方法特别适合按行处理文本文件，是实际开发中最常用的方式之一。

2.3 指定字符编码处理文件

为了避免编码问题，最佳实践是始终明确指定字符编码：

java复制// 明确指定UTF-8编码
try (BufferedReader reader = new BufferedReader(
        new InputStreamReader(
                new FileInputStream("encoded.txt"), StandardCharsets.UTF_8))) {
    // 读取操作...
}

try (BufferedWriter writer = new BufferedWriter(
        new OutputStreamWriter(
                new FileOutputStream("encoded.txt"), StandardCharsets.UTF_8))) {
    // 写入操作...
}

3. 现代Java文件操作API

3.1 NIO.2文件API

Java 7引入了NIO.2 API(java.nio.file包)，提供了更强大、更灵活的文件操作方式：

java复制import java.nio.file.*;
import java.util.List;

// 写入文件
Path path = Paths.get("nio_example.txt");
List<String> lines = List.of("第一行", "第二行", "第三行");
try {
    Files.write(path, lines, StandardCharsets.UTF_8);
} catch (IOException e) {
    e.printStackTrace();
}

// 读取文件
try {
    List<String> readLines = Files.readAllLines(path, StandardCharsets.UTF_8);
    readLines.forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}

NIO.2 API的优点包括：

• 方法更简洁直观
• 提供了Files工具类，包含大量静态方法
• 更好的异常处理
• 支持更多高级功能(如文件属性、符号链接等)

3.2 使用Files类的便捷方法

Files类提供了许多便捷的静态方法：

java复制// 检查文件是否存在
boolean exists = Files.exists(path);

// 创建目录
Path dir = Paths.get("mydir");
if (!Files.exists(dir)) {
    Files.createDirectory(dir);
}

// 复制文件
Path source = Paths.get("source.txt");
Path target = Paths.get("target.txt");
Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);

// 移动/重命名文件
Files.move(source, target, StandardCopyOption.REPLACE_EXISTING);

// 删除文件
Files.deleteIfExists(path);

4. 文件操作实战技巧

4.1 大文件处理策略

处理大文件时，不能一次性读取全部内容到内存，应该使用流式处理：

java复制// 流式读取大文件
try (Stream<String> lines = Files.lines(Paths.get("large_file.txt"))) {
    lines.forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}

// 缓冲写入大文件
try (BufferedWriter writer = Files.newBufferedWriter(
        Paths.get("large_output.txt"), StandardCharsets.UTF_8)) {
    for (int i = 0; i < 1000000; i++) {
        writer.write("Line " + i + "\n");
    }
} catch (IOException e) {
    e.printStackTrace();
}

4.2 文件过滤与搜索

Java 8+结合NIO.2可以方便地实现文件过滤和搜索：

java复制// 查找所有.txt文件
try (Stream<Path> paths = Files.find(
        Paths.get("."),  // 当前目录
        Integer.MAX_VALUE,  // 最大深度
        (path, attrs) -> path.toString().endsWith(".txt"))) {
    paths.forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}

// 遍历目录
try (Stream<Path> paths = Files.walk(Paths.get("."))) {
    paths.filter(Files::isRegularFile)
         .filter(p -> p.toString().endsWith(".java"))
         .forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}

4.3 临时文件处理

临时文件是许多应用场景中需要的功能：

java复制// 创建临时文件
try {
    Path tempFile = Files.createTempFile("prefix_", ".suffix");
    System.out.println("临时文件路径: " + tempFile);
    
    // 使用后删除
    tempFile.toFile().deleteOnExit();
} catch (IOException e) {
    e.printStackTrace();
}

5. 常见问题与解决方案

5.1 文件编码问题排查

乱码是文件操作中最常见的问题之一。解决方法包括：

1. 确认文件实际编码(可使用文本编辑器查看)
2. 读写时使用相同的编码
3. 优先使用UTF-8编码
4. 使用编码检测库(如juniversalchardet)

java复制// 检测文件编码示例(需要额外库)
public static Charset detectCharset(Path file) throws IOException {
    byte[] buffer = new byte[4096];
    try (InputStream is = new FileInputStream(file.toFile())) {
        int length = is.read(buffer);
        UniversalDetector detector = new UniversalDetector(null);
        detector.handleData(buffer, 0, length);
        detector.dataEnd();
        String encoding = detector.getDetectedCharset();
        return encoding != null ? Charset.forName(encoding) : StandardCharsets.UTF_8;
    }
}

5.2 文件锁与并发访问

多线程/多进程访问同一文件时需要考虑同步问题：

java复制// 使用文件锁确保独占访问
try (RandomAccessFile raf = new RandomAccessFile("locked.txt", "rw");
     FileLock lock = raf.getChannel().lock()) {
    // 在此区域内对文件进行操作
    raf.writeChars("独占写入的内容");
} catch (IOException e) {
    e.printStackTrace();
}

5.3 性能优化技巧

1. 使用缓冲流(BufferedReader/BufferedWriter)
2. 对大文件使用流式处理(Files.lines())
3. 减少小文件的频繁打开关闭
4. 考虑使用内存映射文件(MappedByteBuffer)处理超大文件
5. 批量操作时考虑并行流处理

java复制// 并行处理多个文件
try (Stream<Path> paths = Files.walk(Paths.get("data"))) {
    paths.parallel()
         .filter(Files::isRegularFile)
         .filter(p -> p.toString().endsWith(".csv"))
         .forEach(FileOperations::processFile);
} catch (IOException e) {
    e.printStackTrace();
}

6. 文件操作最佳实践

1. 始终关闭资源：使用try-with-resources确保文件句柄被正确关闭
2. 明确指定编码：不要依赖平台默认编码，始终使用UTF-8
3. 处理异常：合理处理IOException，不要简单忽略
4. 路径处理：使用Paths.get()和Path接口，而不是直接拼接字符串
5. 文件存在检查：重要操作前检查文件是否存在和可访问
6. 临时文件清理：确保临时文件在使用后被删除
7. 跨平台考虑：注意路径分隔符和文件系统差异
8. 安全考虑：验证文件路径，防止目录遍历攻击

java复制// 安全文件操作示例
public static void safeFileOperation(String userInput) throws IOException {
    // 规范化路径，防止../等攻击
    Path safePath = Paths.get("base_dir").resolve(userInput).normalize();
    
    // 验证路径是否在允许的目录内
    if (!safePath.startsWith(Paths.get("base_dir"))) {
        throw new SecurityException("非法路径访问");
    }
    
    // 执行文件操作
    try (BufferedReader reader = Files.newBufferedReader(safePath)) {
        // 读取文件内容
    }
}

在实际项目中，我通常会封装一个文件工具类，将常用的文件操作和安全检查集中管理。这样既能保证一致性，又能减少重复代码。例如：

java复制public class FileUtils {
    private static final Charset DEFAULT_CHARSET = StandardCharsets.UTF_8;
    
    public static List<String> readAllLines(Path path) throws IOException {
        return Files.readAllLines(path, DEFAULT_CHARSET);
    }
    
    public static void writeAllLines(Path path, List<String> lines) throws IOException {
        Files.write(path, lines, DEFAULT_CHARSET);
    }
    
    public static void copyDirectory(Path source, Path target) throws IOException {
        Files.walk(source)
             .forEach(src -> {
                 Path dest = target.resolve(source.relativize(src));
                 try {
                     Files.copy(src, dest, StandardCopyOption.REPLACE_EXISTING);
                 } catch (IOException e) {
                     throw new UncheckedIOException(e);
                 }
             });
    }
}

对于文件操作，最常遇到的坑就是资源未正确关闭导致的文件句柄泄漏。这个问题在Windows上尤其明显，因为Windows对文件锁的管理更为严格。我曾经遇到过一个生产环境问题，日志文件无法轮转，就是因为某个地方没有正确关闭文件流。从那以后，我养成了几个习惯：

1. 总是使用try-with-resources
2. 对文件操作进行集中监控和日志记录
3. 编写单元测试验证文件资源是否被正确释放
4. 使用工具检测文件描述符泄漏

另一个经验是，处理用户上传的文件时，一定要进行严格的路径检查和内容验证。曾经有攻击者通过精心构造的文件名尝试访问系统敏感文件，幸好我们有多层防御机制。现在我遵循的原则是：永远不要信任用户提供的文件路径，总是进行规范化处理和权限验证。