Java 实例 – 将文件内容复制到另一个文件（手把手讲解）

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

• 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;演示链接： http://116.62.199.48:7070 ;
• 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 90w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 3100+ 小伙伴加入学习 ，欢迎点击围观

在 Java 编程中，文件操作是一项基础且实用的技能。无论是开发工具类应用、数据处理系统，还是构建文件管理功能，掌握如何高效地复制文件内容都是不可或缺的能力。本文将以“Java 实例 – 将文件内容复制到另一个文件”为核心，从基础概念到高级技巧，逐步拆解这一操作的实现逻辑，并结合具体代码示例，帮助读者构建扎实的文件操作知识体系。

文件复制的本质是将原始文件的字节或字符数据，通过程序读取后写入到目标文件中。这一过程需要借助 Java 提供的输入/输出（I/O）流技术。

输入流与输出流的协作

在 Java 中，文件操作主要通过 InputStream 和 OutputStream 类的子类实现。例如：

• FileInputStream：用于读取字节数据的输入流。
• FileOutputStream：用于写入字节数据的输出流。

这两个类共同协作，形成“读取-写入”的数据传输链路。想象一下，这就像用一根水管将水从一个水池转移到另一个水池：输入流负责“吸水”，输出流负责“注水”，两者配合完成整个传输过程。

基础代码示例

import java.io.*;  

public class FileCopyExample {  
    public static void main(String[] args) {  
        String sourcePath = "source.txt";  
        String targetPath = "target.txt";  

        try (  
            FileInputStream fis = new FileInputStream(sourcePath);  
            FileOutputStream fos = new FileOutputStream(targetPath);  
        ) {  
            int data;  
            while ((data = fis.read()) != -1) {  
                fos.write(data);  
            }  
            System.out.println("文件复制成功！");  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}  

关键点解析

1. 字节级操作：上述代码通过 fis.read() 逐字节读取数据，fos.write(data) 逐字节写入目标文件。
2. try-with-resources：确保流资源在使用后自动关闭，避免内存泄漏。
3. 异常处理：捕获 IOException，防止因文件不存在或权限问题导致程序崩溃。

虽然基础实现能完成文件复制，但直接逐字节操作效率较低。此时，可以引入 缓冲流（BufferedInputStream 和 BufferedOutputStream），提升数据传输的吞吐量。

缓冲流的作用机制

缓冲流的作用类似于在传输过程中添加了一个“中转站”：

• 读取阶段：缓冲流会一次性读取大量数据到内存缓冲区，减少与磁盘的频繁交互。
• 写入阶段：同样利用缓冲区，批量写入数据到目标文件。

这就像用卡车运输货物，相比自行车逐次搬运，效率提升显著。

优化后的代码示例

import java.io.*;  

public class BufferedFileCopy {  
    public static void main(String[] args) {  
        String sourcePath = "source.txt";  
        String targetPath = "target.txt";  

        try (  
            FileInputStream fis = new FileInputStream(sourcePath);  
            BufferedInputStream bis = new BufferedInputStream(fis);  
            FileOutputStream fos = new FileOutputStream(targetPath);  
            BufferedOutputStream bos = new BufferedOutputStream(fos);  
        ) {  
            int data;  
            while ((data = bis.read()) != -1) {  
                bos.write(data);  
            }  
            System.out.println("缓冲流复制成功！");  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}  

性能对比

如果复制的文件是文本文件（如 .txt、.csv），使用字节流可能无法正确处理不同编码格式。此时，应改用 字符流（Reader 和 Writer 类），例如：

• FileReader：按字符读取文本文件。
• FileWriter：按字符写入文本文件。

字符流代码示例

import java.io.*;  

public class CharFileCopy {  
    public static void main(String[] args) {  
        String sourcePath = "source.txt";  
        String targetPath = "target.txt";  

        try (  
            FileReader fr = new FileReader(sourcePath);  
            FileWriter fw = new FileWriter(targetPath);  
        ) {  
            int data;  
            while ((data = fr.read()) != -1) {  
                fw.write(data);  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}  

字符流的优势

1. 编码兼容性：自动处理不同字符编码（如 UTF-8、GBK）。
2. 逻辑清晰：直接操作字符而非字节，代码更易理解。
3. 避免乱码：尤其在处理多语言文本时，字符流能有效避免因字节截断导致的乱码问题。

逐字节或逐字符的读写效率仍有提升空间。通过 字节数组（byte[]） 或 字符数组（char[]） 批量操作数据，能显著减少循环次数，从而提高性能。

批量读写的实现逻辑

1. 分配缓冲区：例如 byte[] buffer = new byte[1024];，定义每次读取的字节数。
2. 循环读取：每次读取尽可能多的数据到缓冲区，再一次性写入目标文件。

批量字节流代码示例

import java.io.*;  

public class BatchFileCopy {  
    private static final int BUFFER_SIZE = 1024;  

    public static void main(String[] args) {  
        String sourcePath = "source.txt";  
        String targetPath = "target.txt";  

        try (  
            FileInputStream fis = new FileInputStream(sourcePath);  
            FileOutputStream fos = new FileOutputStream(targetPath);  
        ) {  
            byte[] buffer = new byte[BUFFER_SIZE];  
            int bytesRead;  
            while ((bytesRead = fis.read(buffer)) != -1) {  
                fos.write(buffer, 0, bytesRead);  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}  

关键参数：缓冲区大小

• 缓冲区过小：增加循环次数，效率降低。
• 缓冲区过大：占用过多内存，可能引发内存不足错误。
• 推荐值：通常以 1KB（1024字节）或 4KB 为起点，根据文件大小动态调整。

在文件复制过程中，可能出现多种异常，例如：

• 文件不存在：FileNotFoundException
• 权限不足：SecurityException
• 磁盘空间不足：IOException

完善的异常处理逻辑

import java.io.*;  

public class SafeFileCopy {  
    public static void copyFile(String source, String target) {  
        try (  
            FileInputStream fis = new FileInputStream(source);  
            FileOutputStream fos = new FileOutputStream(target);  
        ) {  
            byte[] buffer = new byte[4096];  
            int bytesRead;  
            while ((bytesRead = fis.read(buffer)) != -1) {  
                fos.write(buffer, 0, bytesRead);  
            }  
        } catch (FileNotFoundException e) {  
            System.err.println("文件未找到：" + e.getMessage());  
        } catch (IOException e) {  
            System.err.println("I/O 错误：" + e.getMessage());  
        }  
    }  

    public static void main(String[] args) {  
        copyFile("source.txt", "target.txt");  
    }  
}  

关键设计原则

1. 分层捕获异常：针对不同异常类型提供针对性提示。
2. 资源隔离：将文件操作封装到独立方法中，便于复用和维护。
3. 日志记录：通过 System.err 输出错误信息，而非简单 printStackTrace()，避免影响用户体验。

对于超大文件（如 GB 级），单线程复制可能耗时较长。此时，可以尝试以下优化方案：

1. 多线程分块复制：将文件分割为多个块，每个线程处理一块。
2. 异步非阻塞 I/O：利用 NIO 的 FileChannel 实现更高效的传输。

NIO 通道的异步复制示例

import java.io.*;  
import java.nio.*;  
import java.nio.channels.*;  

public class NIOFileCopy {  
    public static void main(String[] args) {  
        String sourcePath = "source.txt";  
        String targetPath = "target.txt";  

        try (  
            FileChannel inputChannel = new FileInputStream(sourcePath).getChannel();  
            FileChannel outputChannel = new FileOutputStream(targetPath).getChannel();  
        ) {  
            // 使用直接缓冲区提升性能  
            ByteBuffer buffer = ByteBuffer.allocateDirect(1024);  
            while (inputChannel.read(buffer) != -1) {  
                buffer.flip();  
                outputChannel.write(buffer);  
                buffer.clear();  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}  

NIO 的优势

• 零拷贝技术：通过 transferTo() 或 transferFrom() 方法，直接由操作系统内核完成数据传输，减少用户态与内核态切换。
• 内存映射文件：使用 map() 方法将文件映射到内存，实现超快速读写（适用于随机访问场景）。

假设需要复制一个 10MB 的图片文件 image.jpg，可以结合上述技术实现高效复制：

public class ImageCopyExample {  
    private static final int BUFFER_SIZE = 8192;  

    public static void main(String[] args) {  
        String source = "image.jpg";  
        String target = "copied_image.jpg";  

        try (  
            FileInputStream fis = new FileInputStream(source);  
            BufferedInputStream bis = new BufferedInputStream(fis);  
            FileOutputStream fos = new FileOutputStream(target);  
            BufferedOutputStream bos = new BufferedOutputStream(fos);  
        ) {  
            byte[] buffer = new byte[BUFFER_SIZE];  
            int bytesRead;  
            while ((bytesRead = bis.read(buffer)) != -1) {  
                bos.write(buffer, 0, bytesRead);  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}  

关键点总结

1. 缓冲流与批量操作结合：平衡性能与内存占用。
2. 选择合适缓冲区大小：根据文件类型调整（如图片可选择 8KB 或更大）。
3. 保持代码简洁性：通过 try-with-resources 自动管理资源。

通过实验测试不同方法的复制时间，可得出以下结论：

场景选择建议

• 小文件（<1MB）：基础字节流或字符流即可满足需求。
• 中等文件（1MB-100MB）：推荐使用缓冲流 + 批量操作。
• 超大文件（>100MB）：优先考虑 NIO 通道或分块多线程方案。

通过本文的讲解，读者应能掌握从基础到进阶的 Java 文件复制技术，并根据实际需求选择最优方案。无论是处理文本文件、二进制文件，还是应对超大文件挑战，都能通过合理设计流结构、优化缓冲策略，甚至结合 NIO 技术，实现高效稳定的文件操作。

在编程实践中，建议始终遵循以下原则：

1. 代码健壮性：通过 try-with-resources 和多层异常捕获确保程序可靠性。
2. 性能平衡：根据文件大小和系统资源动态调整缓冲区大小及方法选择。
3. 可维护性：将文件操作封装为独立方法或工具类，便于未来扩展与调试。

掌握文件复制这一核心技能后，读者可进一步探索更复杂的文件系统操作，如文件加密传输、分布式文件同步等，逐步构建更强大的 Java 应用系统。