Java 实例 – 将文件内容复制到另一个文件（超详细）

Java 实例 – 将文件内容复制到另一个文件

在日常开发中，我们经常会遇到需要将一个文件的内容完整地复制到另一个文件的场景。比如，备份配置文件、迁移日志数据、批量处理文本内容等。这类操作看似简单，但背后涉及文件读写、流管理、异常处理等多个关键知识点。掌握 Java 中如何高效、安全地实现文件复制，是每位开发者必须具备的基础技能。

本文将通过一个完整的 Java 实例，带你一步步理解文件复制的实现原理。我们不会只停留在“复制代码”层面，而是深入讲解每一步背后的逻辑，帮助你真正理解“流”是如何在程序和文件之间传递数据的。无论你是初学者，还是已经接触过 Java 的中级开发者，都能从这篇文章中获得实用价值。

为什么文件复制是开发中的常见需求？

想象一下，你正在开发一个日志分析系统。每天系统都会生成一个日志文件，大小可能达到几百 MB。为了防止数据丢失，你希望在每天凌晨自动将当天的日志文件备份一份，存放到另一个目录中。

这个“备份”操作，本质上就是“将一个文件的内容复制到另一个文件”。虽然听起来很基础，但如果实现不当，可能会导致内存溢出、文件损坏，甚至程序崩溃。所以，掌握正确的文件复制方式，不仅是为了完成任务，更是为了写出健壮、可维护的代码。

在 Java 中，实现文件复制的核心思想是：使用输入流读取源文件数据，再通过输出流写入目标文件。整个过程就像一条“数据河流”，从源头（原文件）出发，经过管道（流），最终流入终点（目标文件）。

使用 FileInputStream 和 FileOutputStream 实现复制

最原始、最直接的方式是使用 FileInputStream 和 FileOutputStream。这种方式适合处理小文件，因为它会将整个文件一次性读入内存。我们来看一个完整的代码示例：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileCopyExample {

    public static void main(String[] args) {
        // 定义源文件路径和目标文件路径
        String sourceFilePath = "src/main/resources/input.txt";
        String targetFilePath = "src/main/resources/output.txt";

        // 创建输入流和输出流对象
        FileInputStream inputStream = null;
        FileOutputStream outputStream = null;

        try {
            // 1. 创建文件输入流，连接到源文件
            inputStream = new FileInputStream(sourceFilePath);

            // 2. 创建文件输出流，连接到目标文件（若不存在则自动创建）
            outputStream = new FileOutputStream(targetFilePath);

            // 3. 定义缓冲区，用于分批读取数据（避免一次性加载整个文件到内存）
            byte[] buffer = new byte[1024]; // 每次最多读取 1024 字节
            int bytesRead; // 记录每次实际读取的字节数

            // 4. 循环读取数据，直到读完源文件
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                // 5. 将读取到的数据写入目标文件
                outputStream.write(buffer, 0, bytesRead);
            }

            System.out.println("文件复制成功：从 " + sourceFilePath + " 到 " + targetFilePath);

        } catch (IOException e) {
            // 6. 捕获可能的异常，比如文件不存在、权限不足等
            System.err.println("文件复制过程中发生错误：" + e.getMessage());
            e.printStackTrace();

        } finally {
            // 7. 确保资源被释放，即使发生异常也要关闭流
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    System.err.println("关闭输入流时出错：" + e.getMessage());
                }
            }
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    System.err.println("关闭输出流时出错：" + e.getMessage());
                }
            }
        }
    }
}

代码逐行解析

• FileInputStream sourceFilePath：创建一个输入流，用来读取原始文件。
• FileOutputStream targetFilePath：创建一个输出流，用来写入目标文件。
• byte[] buffer = new byte[1024]：使用缓冲区分批读取，避免大文件一次性加载到内存。
• inputStream.read(buffer)：返回值为 -1 表示读取完毕，否则返回实际读取的字节数。
• outputStream.write(buffer, 0, bytesRead)：写入指定数量的字节，避免写入空数据。
• finally 块：确保流被关闭，防止资源泄漏。

⚠️ 注意：这种写法虽然基础，但有一个致命缺点——没有使用 try-with-resources。在实际项目中，应优先使用自动资源管理，避免手动关闭流。

使用 try-with-resources 优化资源管理

Java 7 引入了 try-with-resources 语法，可以自动管理资源的关闭。这不仅让代码更简洁，还能有效防止资源泄漏。我们来优化上面的代码：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileCopyWithResources {

    public static void main(String[] args) {
        String sourceFilePath = "src/main/resources/input.txt";
        String targetFilePath = "src/main/resources/output.txt";

        // 使用 try-with-resources 自动关闭流
        try (FileInputStream inputStream = new FileInputStream(sourceFilePath);
             FileOutputStream outputStream = new FileOutputStream(targetFilePath)) {

            byte[] buffer = new byte[1024];
            int bytesRead;

            while ((bytesRead = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, bytesRead);
            }

            System.out.println("文件复制成功：从 " + sourceFilePath + " 到 " + targetFilePath);

        } catch (IOException e) {
            System.err.println("文件复制失败：" + e.getMessage());
            e.printStackTrace();
        }
    }
}

优势对比

✅ 建议：在任何涉及文件、数据库、网络连接等资源的操作中，优先使用 try-with-resources。

使用 Files.copy() 方法（Java 7+）

如果你使用的是 Java 7 或更高版本，Java 提供了更高级的 Files.copy() 方法，它封装了底层流操作，代码更简洁，性能也更优。

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;

public class FileCopyUsingFiles {

    public static void main(String[] args) {
        String sourcePath = "src/main/resources/input.txt";
        String targetPath = "src/main/resources/output.txt";

        // 将路径转换为 Path 对象
        Path source = Paths.get(sourcePath);
        Path target = Paths.get(targetPath);

        try {
            // 使用 Files.copy() 复制文件
            // StandardCopyOption.REPLACE_EXISTING：若目标文件已存在，则覆盖
            Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);

            System.out.println("文件复制成功：从 " + sourcePath + " 到 " + targetPath);

        } catch (IOException e) {
            System.err.println("文件复制失败：" + e.getMessage());
            e.printStackTrace();
        }
    }
}

方法优势

• 一行代码完成复制，无需手动管理流。
• 支持覆盖、原子复制、属性保留等高级选项。
• 内部使用高效的 NIO.2 API，适合处理大文件。

📌 小贴士：StandardCopyOption.REPLACE_EXISTING 是一个好习惯，避免因目标文件已存在而抛出异常。

处理大文件的性能优化建议

当文件超过 100 MB 甚至更大时，内存使用会成为瓶颈。此时，缓冲区大小和流的使用方式至关重要。

💡 缓冲区越大，系统调用越少，性能越好，但占用内存也越多。建议根据实际环境权衡。

常见错误与解决方案

总结：掌握 Java 实例 – 将文件内容复制到另一个文件

通过本文的学习，你已经掌握了三种实现文件复制的核心方法：

1. 使用 FileInputStream 和 FileOutputStream，适合学习原理；
2. 使用 try-with-resources，提升代码安全性和可读性；
3. 使用 Files.copy()，最简洁高效的现代方式。

无论你是做日常开发，还是构建系统级工具，文件复制都是高频操作。真正理解其底层机制，才能写出既高效又可靠的代码。

记住：不要只复制代码，要理解“流”的流动逻辑。就像一条河流，数据从源文件出发，经过缓冲区，最终流入目标文件。你写的每一行代码，都是在为这条河流搭建桥梁和堤坝。

下一次当你需要复制文件时，不妨停下来想一想：我是否用了正确的流？是否合理管理了资源？是否考虑了大文件的性能？

这才是一个专业开发者应有的思考方式。