Java新手求教：如何使用Path对象复制目录下所有文件？

Hey there! I see you're new to Java and working on copying files between directories using Java NIO's Path API—great choice, since it's more modern and flexible than the old java.io stuff. Let's fix up your code and break down what's going wrong, plus how to do it right.

First, let's spot the issues in your current code: #

• You're only grabbing the file name with getFileName() instead of keeping the full source path. When you pass that to Files.copy(), it won't be able to find the file because it's looking in the current working directory, not your source folder.
• The second argument to Files.copy() needs to be the full target file path, not just the target directory. If you pass a directory here, Java will throw an error because it doesn't know what to name the copied file.
• You had a typo in your error message for the destination directory—you used source instead of destination, which would confuse anyone using the method.
• Collecting all files into an ArrayList first is unnecessary; you can copy them directly as you iterate through the directory stream.

Here's the corrected, robust version of your method: #

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

public class FileCopier {

    // Copies all regular files from source directory to destination directory
    public static void copyFiles(String sourceDir, String destinationDir) throws IOException {
        Path sourcePath = Paths.get(sourceDir);
        Path destinationPath = Paths.get(destinationDir);

        // Validate source directory
        if (!Files.exists(sourcePath) || !Files.isDirectory(sourcePath)) {
            System.out.println("Source directory '" + sourceDir + "' doesn't exist or isn't a directory.");
            return;
        }

        // Create destination directory if it doesn't exist (including parent folders)
        if (!Files.exists(destinationPath)) {
            Files.createDirectories(destinationPath);
            System.out.println("Destination directory didn't exist—created it at: " + destinationDir);
        } else if (!Files.isDirectory(destinationPath)) {
            System.out.println("Destination path '" + destinationDir + "' isn't a directory.");
            return;
        }

        // Iterate through source directory and copy files
        int copiedFileCount = 0;
        try (DirectoryStream<Path> directoryStream = Files.newDirectoryStream(sourcePath)) {
            for (Path sourceFile : directoryStream) {
                // Only copy regular files (skip subdirectories)
                if (Files.isRegularFile(sourceFile)) {
                    // Build the full target file path: destination directory + source file name
                    Path targetFile = destinationPath.resolve(sourceFile.getFileName());
                    
                    // Copy the file—use REPLACE_EXISTING to overwrite if target exists
                    Files.copy(sourceFile, targetFile, StandardCopyOption.REPLACE_EXISTING);
                    
                    copiedFileCount++;
                    System.out.println("Copied: " + sourceFile.getFileName());
                }
            }
        } catch (IOException e) {
            System.err.println("Error during file copy: " + e.getMessage());
            throw e; // Re-throw if you want the caller to handle the exception
        }

        // Feedback on copy result
        if (copiedFileCount == 0) {
            System.out.println("No files found to copy in source directory '" + sourceDir + "' (or all entries are subdirectories).");
        } else {
            System.out.println("Copy completed successfully! Copied " + copiedFileCount + " file(s).");
        }
    }

    // Test the method
    public static void main(String[] args) {
        try {
            // Replace these paths with your actual source and destination
            copyFiles("./my-source-folder", "./my-destination-folder");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Key things to note about this implementation: #

• Paths.get(): Converts string paths to Path objects, which Java NIO uses to handle file system paths in an OS-agnostic way (no need for that OSType parameter anymore!).
• Files.createDirectories(): Recursively creates the destination directory and any missing parent directories—way more convenient than manual checks.
• Path.resolve(): Safely joins the destination directory path with the source file name, automatically using the correct path separator for your OS (slash for Unix, backslash for Windows).
• StandardCopyOption.REPLACE_EXISTING: Tells Java to overwrite the target file if it already exists. If you don't want this behavior, just remove this argument—Java will throw an exception instead of overwriting.
• Try-with-resources: The DirectoryStream is auto-closed when we're done with it, preventing resource leaks.
• File vs Directory Check: We skip subdirectories with Files.isRegularFile()—if you need to copy subdirectories recursively, you can use Files.walk() instead (let me know if you want that example!).

Bonus fixes from your original code: #

• Removed the redundant OSType parameter (Java NIO handles OS paths automatically)
• Fixed the typo in the destination directory error message
• Cut out the unnecessary ArrayList to make the code more efficient
• Added clearer feedback messages for the user

内容的提问来源于stack exchange，提问作者Huckleberry