7

我正在开发一个程序，该程序将（希望）比较给定目录中的所有文件，识别重复项，将它们添加到列表中，然后将列表显示给用户，以便他们可以验证他们希望在删除这些文件之前删除它们，我'我严重卡住了。到目前为止，我已经能够递归地列出所有文件，并且我一直在比较它们以找到重复项。我很快意识到要完成我想要的，我需要比较多个文件属性。并非所有文件都是文本文件，就互联网上的示例代码而言，比较文本主要是我发现的，我正在尝试更多地了解二进制数据，因为比较字节数组和文件名是我能来的最好的跟上。具体来说我' 我询问哪些属性最好进行比较，以平衡查找重复项的准确性和能够处理合理大小的目录？如果你不介意我怎么能在我的代码中实现它？希望我的问题不是太糟糕，我非常感谢我能得到的任何帮助。这就是我所拥有的，是的，我在这里找到的一些方法和第二个文件，以防你想知道。PS如果我错过了任何无意义的变量，我真的很抱歉，我在发布之前尝试清理一下代码 如果您想知道的话，我确实在这里找到了一些方法和第二个文件。PS如果我错过了任何无意义的变量，我真的很抱歉，我在发布之前尝试清理一下代码 如果您想知道的话，我确实在这里找到了一些方法和第二个文件。PS如果我错过了任何无意义的变量，我真的很抱歉，我在发布之前尝试清理一下代码

ListFilesInDir.java

import java.io.*;
import java.nio.file.Files;
import java.nio.file.attribute.*;
import java.security.*;
import java.util.*;

public final class ListFilesInDir {

static File startingDir;

static List<File> files;
static List<File> dirs;
static TreeMap<Integer, File> duplicates;
static ArrayList<Integer> usedIndexes = new ArrayList<Integer>();
static ArrayList<File> duplicateList = new ArrayList<File>();

static File out = new File("ListDuplicateFiles.txt");
static PrintWriter output;

static int key = 0;
static String tabString;
static TreeMap<Integer, File> tMap = new TreeMap<Integer, File>();

static int num1 = 0;
static int num2 = 0;
static File value1 = null;
static File value2 = null;
static String path1 = null;
static String name1 = null;
static String path2 = null;
static String name2 = null;

public static void main(String[] args) throws FileNotFoundException {
    new ListFilesInDir(args[0]);
}

public ListFilesInDir(String string) throws FileNotFoundException {
    startingDir = new File(string);
    dirs = new ArrayList<File>();
    duplicates = new TreeMap<Integer, File>();
    output = new PrintWriter(out);

    getFiles(startingDir);
    compareFiles();
    writeDuplicateList();
}

public void getFiles(File root) throws FileNotFoundException {
    System.out.println("Adding files to list...");
    ListFilesInDir.files = getFileList(root);
    for (File file : files) {
        if (!file.isFile()) {
            System.out.println("Adding DIR: " + key + " name: " + file);
            dirs.add(file);
        } else {
            System.out.println("Adding FILE: " + key + " name: " + file);
            tMap.put(key, file);
        }
        key++;
    }
    System.out.println(dirs.size());
    System.out.println("Complete");
}

public static void compareFiles() throws FileNotFoundException {
    System.out.println("Preparing to compare files...");
    for (num1 = 0; num1 < files.size(); num1++) {
        for (num2 = 0; num2 < files.size(); num2++) {

            if (num1 != num2) {
                value1 = files.get(num1);
                value2 = files.get(num2);
                path1 = value1.getAbsolutePath();
                path2 = value2.getAbsolutePath();
                name1 = path1.substring(path1.lastIndexOf(File.separator));
                name2 = path2.substring(path2.lastIndexOf(File.separator));
                HashMap<Integer, File> testMap = new HashMap<Integer, File>();

                System.out.println(num1 + "|" + num2 + " : " + value1
                        + " - " + value2);
                if (CompareBinaries.fileContentsEquals(
                        value1.getAbsolutePath(), value2.getAbsolutePath()) == true) {
                    if (testMap.put(num1, value1) != null) {
                        TreeSet<File> fileTreeSet;
                    }
                    addDuplicate(num1, value1);
                    files.remove(num1);

                    System.out.println("added(binary): " + num1 + ":"
                            + value1);

                } else if (value1.getName().equalsIgnoreCase(
                        value2.getName())) {
                    addDuplicate(num1, value1);
                    files.remove(num1);
                    System.out.println("added(name): " + num1 + ":"
                            + value1);
                }
            }
        }
    }
    System.out.println("Complete");

}

public static void writeDuplicateList() {
    int printKey = 0;
    for (File file : duplicateList) {
        output.printf("%03d | %s\n", printKey, file);
        System.out.printf("%03d | %s\n", printKey, file);
        printKey++;
    }

    output.append(docsInfo());
    output.close();
    output.flush();

    System.out.println("\n"+files.size()+" files in "+startingDir.getAbsolutePath() +", "+duplicateList.size()+" duplicate files.");
}

static public String docsInfo() {
    String s = "\n\n" + files.size() + " files in "
            + startingDir.getAbsolutePath() + ", " + duplicates.size()
            + " duplicate files.";
    return s;
}

static public List<File> getFileList(File file)
        throws FileNotFoundException {
    List<File> result = getUnsortedFileList(file);
    Collections.sort(result);
    return result;
}

static private List<File> getUnsortedFileList(File file)
        throws FileNotFoundException {
    List<File> result = new ArrayList<File>();
    File[] filesAndDirs = file.listFiles();
    List<File> filesDirs = Arrays.asList(filesAndDirs);
    int dirKey = 0;

    for (File fileList : filesDirs) {
        result.add(fileList);
        if (!fileList.isFile()) {

            List<File> deeperList = getUnsortedFileList(fileList);
            result.addAll(deeperList);
        }
    }
    return result;
    }

        static private void validateDir(File dir) throws FileNotFoundException {
    if (dir == null)
        throw new IllegalArgumentException("Directory is null!");
    if (!dir.exists())
        throw new FileNotFoundException("Directory doesn't exist: " + dir);
    if (!dir.isDirectory())
        throw new IllegalArgumentException(dir + "is not a directory!");
    if (!dir.canRead())
        throw new IllegalArgumentException("Directory cannot be read: "
                + dir);
     }

         public static void addDuplicate(int i, File file)throws FileNotFoundException{
          if (!duplicates.containsKey(i)) {
           duplicates.put(i, file);
               duplicateList.add(file);

          }
     }
    }

比较二进制文件.java

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Arrays;


public class CompareBinaries {

private final static int BUFFSIZE = 1024;
private static byte buff1[] = new byte[BUFFSIZE];
private static byte buff2[] = new byte[BUFFSIZE];

public static boolean inputStreamEquals(InputStream is1, InputStream is2) {
    if(is1 == is2) return true;

    if(is1 == null && is2 == null) {
        System.out.println("both input streams are null");
        return true;
    }

    if(is1 == null || is2 == null) return false;
    try {
        int read1 = -1;
        int read2 = -1;

        do {
            int offset1 = 0;
            while (offset1 < BUFFSIZE
                        && (read1 = is1.read(buff1, offset1, BUFFSIZE-offset1)) >= 0) {
                        offset1 += read1;
                }

            int offset2 = 0;
            while (offset2 < BUFFSIZE
                        && (read2 = is2.read(buff2, offset2, BUFFSIZE-offset2)) >= 0) {
                        offset2 += read2;
                }
            if(offset1 != offset2) return false;
            if(offset1 != BUFFSIZE) {
                Arrays.fill(buff1, offset1, BUFFSIZE, (byte)0);
                Arrays.fill(buff2, offset2, BUFFSIZE, (byte)0);
            }
            if(!Arrays.equals(buff1, buff2)) return false;
        } while(read1 >= 0 && read2 >= 0);
        if(read1 < 0 && read2 < 0) return true; // both at EOF
        return false;

    } catch (Exception ei) {
        return false;
    }
}

public static boolean fileContentsEquals(File file1, File file2) {
    InputStream is1 = null;
    InputStream is2 = null;
    if(file1.length() != file2.length()) return false;

    try {
        is1 = new FileInputStream(file1);
        is2 = new FileInputStream(file2);

        return inputStreamEquals(is1, is2);

    } catch (Exception ei) {
        return false;
    } finally {
        try {
            if(is1 != null) is1.close();
            if(is2 != null) is2.close();
        } catch (Exception ei2) {}
    }
}

public static boolean fileContentsEquals(String fn1, String fn2) {
    return fileContentsEquals(new File(fn1), new File(fn2));
}

}

4

3 回答 3

2

您可以使用散列函数来比较两个文件——两个文件（在不同的文件夹中）可以具有相同的名称和属性（例如长度）但内容不同。例如，您可以创建一个文本文件，然后将其复制到不同的文件夹中，更改内容中的一个字母。

哈希函数对以数字结尾的文件内容进行了一些巧妙的数学运算，即使内容的微小差异也会以两个非常不同的数字结尾。

以 md5 哈希函数为例，它从任意长度的字节数组中生成一个 16 字节的数字。虽然理论上可以创建两个 md5 相同但内容不同的文件，但概率很低（而两个文件名称和大小相同但内容不同是一个相对较高的概率事件）

关键是，您可以建立一个文件内容的 md5 表，这只需计算一次并且可以快速比较 - 如果 md5 不同，则文件不同且有 100% 的置信度。只有在不太可能的情况下，md5 相同，您才必须采用逐字节比较来确定 100%。

于 2012-11-03T12:52:13.870 回答
1

最近在处理我的项目工作时，我发现了一个关于使用 SHA 算法接收重复文件名和目录的好备忘录

看看它： https ://jakut.is/2011/03/15/a-java-program-to-list-all/

可能对你有用

于 2013-04-21T17:45:23.037 回答
1

我的建议：遍历一个目录树，按名称与另一个目录树进行比较。然后，对于每个匹配对，比较文件大小和最后修改时间，如果都相等，则进行直接的逐字节比较。

有两个步骤来实现这个（如果添加了示例代码的链接）：

  1. 遍历两个目录以获取完整列表。Java 通过 Java 7 和Files.walkFileTree(). 您遍历一个目录树并将每个条目与另一个目录树进行比较。我在这里发布了一些示例代码进行此类比较（我的示例代码应该可以帮助您完成此步骤，但并没有 100% 解决您的问题）
  2. 比较两个文件是否相等。可以比较几件事：
    • 文件名。这很明显，因为无论如何都需要在第二棵树中找到文件。
    • 文件大小，上次修改时间：是BasicFileAttributes您在遍历树时获得的一部分。请参阅有关如何为第二个文件获取它的示例代码。
    • 内容。如上所述，您可以计算某种 crc、md5、sha。发生的情况是，您将阅读这两个文件的全部内容。所以，我的建议是，直接逐字节比较，例如与 [ Arrays.equals()]( http://docs.oracle.com/javase/7/docs/api/java/util/Arrays.html#equals(byte [] , 字节 []))
于 2013-08-14T12:08:18.777 回答