Java中把一个文件夹下的所有文件复制到另一个文件夹的完整实现方案

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;

/**
 * 文件夹复制工具类（支持多级目录、文件覆盖）
 */
public class FolderCopyUtil {

    /**
     * 核心方法：复制源文件夹下的所有文件/目录到目标文件夹
     * @param sourceDirPath 源文件夹路径（如：D:/source）
     * @param targetDirPath 目标文件夹路径（如：D:/target）
     * @throws IOException IO异常（文件无法读取/写入）
     */
    public static void copyFolder(String sourceDirPath, String targetDirPath) throws IOException {
        File sourceDir = new File(sourceDirPath);
        File targetDir = new File(targetDirPath);

        // 步骤1：校验源文件夹合法性
        if (!sourceDir.exists()) {
            throw new IOException("源文件夹不存在：" + sourceDirPath);
        }
        if (!sourceDir.isDirectory()) {
            throw new IOException("路径不是合法文件夹：" + sourceDirPath);
        }

        // 步骤2：创建目标文件夹（递归创建多级目录，已存在则无影响）
        if (!targetDir.exists()) {
            boolean isCreated = targetDir.mkdirs();
            if (!isCreated) {
                throw new IOException("目标文件夹创建失败：" + targetDirPath);
            }
        }

        // 步骤3：遍历源文件夹下的所有文件/子目录
        File[] files = sourceDir.listFiles();
        if (files == null) { // 源文件夹为空或无读取权限
            return;
        }

        for (File file : files) {
            String targetFilePath = targetDirPath + File.separator + file.getName();
            if (file.isFile()) {
                // 步骤4：复制文件（覆盖已存在的目标文件）
                copyFile(file, new File(targetFilePath));
                System.out.println("文件复制成功：" + file.getPath() + " → " + targetFilePath);
            } else if (file.isDirectory()) {
                // 步骤5：递归复制子目录
                copyFolder(file.getPath(), targetFilePath);
                System.out.println("目录复制成功：" + file.getPath() + " → " + targetFilePath);
            }
        }
    }

    /**
     * 辅助方法：复制单个文件（使用NIO FileChannel，效率更高）
     * @param sourceFile 源文件
     * @param targetFile 目标文件
     * @throws IOException IO异常
     */
    private static void copyFile(File sourceFile, File targetFile) throws IOException {
        // 覆盖目标文件（若已存在则删除后重建）
        if (targetFile.exists()) {
            boolean isDeleted = targetFile.delete();
            if (!isDeleted) {
                throw new IOException("目标文件覆盖失败，无法删除已有文件：" + targetFile.getPath());
            }
        }

        // 使用NIO通道复制（比传统字节流效率更高）
        try (FileInputStream fis = new FileInputStream(sourceFile);
             FileOutputStream fos = new FileOutputStream(targetFile);
             FileChannel inChannel = fis.getChannel();
             FileChannel outChannel = fos.getChannel()) {

            // 批量传输字节，避免逐字节复制，提升大文件复制效率
            long transferred = 0;
            long fileSize = inChannel.size();
            while (transferred < fileSize) {
                transferred += inChannel.transferTo(transferred, fileSize - transferred, outChannel);
            }
        }
    }

    // 测试方法
    public static void main(String[] args) {
        // 替换为你的源文件夹和目标文件夹路径
        String sourceDir = "D:/test/source";
        String targetDir = "D:/test/target";

        try {
            copyFolder(sourceDir, targetDir);
            System.out.println("文件夹复制完成！");
        } catch (IOException e) {
            System.err.println("文件夹复制失败：" + e.getMessage());
            e.printStackTrace();
        }
    }
}

if (targetFile.exists()) {
    System.out.println("目标文件已存在，跳过复制：" + targetFile.getPath());
    return;
}

import java.io.IOException;
import java.nio.file.*;

public class FolderCopyWithFilesUtil {
    public static void copyFolder(String sourceDirPath, String targetDirPath) throws IOException {
        Path sourcePath = Paths.get(sourceDirPath);
        Path targetPath = Paths.get(targetDirPath);

        // 递归复制目录，配置复制选项（覆盖已存在文件）
        Files.walkFileTree(sourcePath, new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
                // 创建目标目录（递归）
                Path targetDir = targetPath.resolve(sourcePath.relativize(dir));
                if (!Files.exists(targetDir)) {
                    Files.createDirectories(targetDir);
                }
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                // 复制文件（覆盖已存在）
                Path targetFile = targetPath.resolve(sourcePath.relativize(file));
                Files.copy(file, targetFile, StandardCopyOption.REPLACE_EXISTING);
                System.out.println("复制文件：" + file + " → " + targetFile);
                return FileVisitResult.CONTINUE;
            }
        });
    }

    public static void main(String[] args) {
        String sourceDir = "D:/test/source";
        String targetDir = "D:/test/target";
        try {
            copyFolder(sourceDir, targetDir);
            System.out.println("复制完成！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}