文本夹比对工具

 

比对两个文件夹是否一致的工具类，具体实现如下：

package com.whb;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class FolderComparator {

    public static class FolderDiff {
        private final List<Path> missingInFirst = new ArrayList<>();
        private final List<Path> missingInSecond = new ArrayList<>();
        private final List<Path> sizeMismatch = new ArrayList<>();
        private final List<Path> contentMismatch = new ArrayList<>();
        private final Map<Path, Long> sizeDetails = new HashMap<>();
        private int totalFilesCompared;
        private int identicalFiles;

        public void addMissingInFirst(Path path) {
            missingInFirst.add(path);
        }

        public void addMissingInSecond(Path path) {
            missingInSecond.add(path);
        }

        public void addSizeMismatch(Path path) {
            sizeMismatch.add(path);
        }

        public void addContentMismatch(Path path) {
            contentMismatch.add(path);
        }

        public void recordSize(Path path, long size) {
            sizeDetails.put(path, size);
        }

        public void incrementTotal() {
            totalFilesCompared++;
        }

        public void incrementIdentical() {
            identicalFiles++;
        }

        public boolean isIdentical() {
            return missingInFirst.isEmpty() && 
                   missingInSecond.isEmpty() && 
                   sizeMismatch.isEmpty() && 
                   contentMismatch.isEmpty();
        }

        public void printReport() {
            System.out.println("\n===== 文件夹比对报告 =====");
            System.out.println("总文件数: " + totalFilesCompared);
            System.out.println("一致文件数: " + identicalFiles);
            System.out.println("差异文件数: " + 
                              (totalFilesCompared - identicalFiles));
            
            if (isIdentical()) {
                System.out.println("\n两个文件夹内容完全一致");
                return;
            }
            
            printSection("第一个文件夹中缺失的文件", missingInFirst);
            printSection("第二个文件夹中缺失的文件", missingInSecond);
            printSection("文件大小不一致的文件", sizeMismatch);
            printSection("文件内容不一致的文件", contentMismatch);
            
            // 打印详细大小差异
            if (!sizeMismatch.isEmpty()) {
                System.out.println("\n文件大小差异详情:");
                for (Path path : sizeMismatch) {
                    Long size1 = sizeDetails.get(path);
                    Long size2 = sizeDetails.get(path.resolve("__second__"));
                    System.out.printf("  %s: %d bytes vs %d bytes\n", 
                                     path, size1, size2);
                }
            }
        }
        
        private void printSection(String title, List<Path> paths) {
            if (!paths.isEmpty()) {
                System.out.println("\n" + title + " (" + paths.size() + "):");
                for (Path path : paths) {
                    System.out.println("  " + path);
                }
            }
        }
    }

    public static FolderDiff compareFolders(Path firstFolder, Path secondFolder) throws IOException {
        if (!Files.isDirectory(firstFolder)) {
            throw new IllegalArgumentException(firstFolder + " 不是文件夹");
        }
        if (!Files.isDirectory(secondFolder)) {
            throw new IllegalArgumentException(secondFolder + " 不是文件夹");
        }

        FolderDiff diff = new FolderDiff();
        
        // 获取所有文件的相对路径
        Set<Path> firstFiles = listFilesRecursively(firstFolder);
        Set<Path> secondFiles = listFilesRecursively(secondFolder);
        
        // 找出缺失的文件
        for (Path path : firstFiles) {
            if (!secondFiles.contains(path)) {
                diff.addMissingInSecond(path);
            }
        }
        for (Path path : secondFiles) {
            if (!firstFiles.contains(path)) {
                diff.addMissingInFirst(path);
            }
        }
        
        // 比较共同文件
        Set<Path> commonFiles = new HashSet<>(firstFiles);
        commonFiles.retainAll(secondFiles);
        
        for (Path relativePath : commonFiles) {
            diff.incrementTotal();
            Path firstFile = firstFolder.resolve(relativePath);
            Path secondFile = secondFolder.resolve(relativePath);
            
            // 比较文件大小
            long firstSize = Files.size(firstFile);
            long secondSize = Files.size(secondFile);
            diff.recordSize(relativePath, firstSize);
            diff.recordSize(relativePath.resolve("__second__"), secondSize);
            
            if (firstSize != secondSize) {
                diff.addSizeMismatch(relativePath);
                continue;
            }
            
            // 大小相同的情况下比较内容
            if (compareFileContent(firstFile, secondFile)) {
                diff.incrementIdentical();
            } else {
                diff.addContentMismatch(relativePath);
            }
        }
        
        return diff;
    }

    private static Set<Path> listFilesRecursively(Path folder) throws IOException {
        try (Stream<Path> paths = Files.walk(folder)) {
            return paths.filter(Files::isRegularFile)
                        .map(folder::relativize)
                        .collect(Collectors.toSet());
        }
    }

    private static boolean compareFileContent(Path firstFile, Path secondFile) {
        try {
            long size = Files.size(firstFile);
            
            // 小文件使用单次读取比较
            if (size <= 8192) {
                byte[] firstBytes = Files.readAllBytes(firstFile);
                byte[] secondBytes = Files.readAllBytes(secondFile);
                return Arrays.equals(firstBytes, secondBytes);
            }
            
            // 大文件使用缓冲比较
            try (InputStream is1 = new BufferedInputStream(Files.newInputStream(firstFile));
                 InputStream is2 = new BufferedInputStream(Files.newInputStream(secondFile))) {
                
                byte[] buffer1 = new byte[8192];
                byte[] buffer2 = new byte[8192];
                
                int bytesRead1;
                while ((bytesRead1 = is1.read(buffer1)) != -1) {
                    int bytesRead2 = is2.read(buffer2, 0, bytesRead1);
                    if (bytesRead2 != bytesRead1) {
                        return false;
                    }
                    for (int i = 0; i < bytesRead1; i++) {
                        if (buffer1[i] != buffer2[i]) {
                            return false;
                        }
                    }
                }
                
                // 检查第二个文件是否还有剩余内容
                return is2.read() == -1;
            }
        } catch (IOException e) {
            System.err.println("比较文件内容时出错: " + e.getMessage());
            return false;
        }
    }

    public static void main(String[] args) {
//        if (args.length != 2) {
//            System.out.println("用法: java FolderComparator <第一个文件夹路径> <第二个文件夹路径>");
//            System.out.println("示例: java FolderComparator C:/folder1 D:/folder2");
//            return;
//        }

        String firstFolderPath = "/Users/whbt/dir1";
        String secondFolderPath = "/Users/whb/dir2";
        Path firstFolder = Paths.get(firstFolderPath);
        Path secondFolder = Paths.get(secondFolderPath);

        
        try {
            System.out.println("开始比对文件夹...");
            System.out.println("文件夹1: " + firstFolder.toAbsolutePath());
            System.out.println("文件夹2: " + secondFolder.toAbsolutePath());
            
            long startTime = System.currentTimeMillis();
            FolderDiff diff = compareFolders(firstFolder, secondFolder);
            long duration = System.currentTimeMillis() - startTime;
            
            diff.printReport();
            
            System.out.printf("\n比对完成! 耗时: %.2f 秒%n", duration / 1000.0);
        } catch (IOException e) {
            System.err.println("比对过程中出错: " + e.getMessage());
            e.printStackTrace();
        }
    }
}