Java：如何不仅按名称搜索文件夹中的重复文件，还按大小和内容搜索重复文件？

问题描述 投票：0回答：5

我想创建一个 Java 应用程序来识别重复项。到目前为止，我只能通过名称找到重复项，但我还需要大小、文件类型，也许还需要内容。这是我到目前为止的代码，使用 

HashMap
:

public static void find(Map<String, List<String>> lists, File dir) {
    for (File f : dir.listFiles()) {
        if (f.isDirectory()) {
            find(lists, f);
        } else {
            String hash = f.getName() + f.length();
            List<String> list = lists.get(hash);
            if (list == null) {
                list = new LinkedList<String>();
                lists.put(hash, list);
            }
            list.add(f.getAbsolutePath());
        }
    }
}
java hashmap duplicates size
5个回答
2
投票

如果两个文件具有相同的扩展名和相同的文件大小，则认为它们相等，只需创建一个表示这种“相等”的对象即可。所以，你会做这样的事情：

public class FileEquality {
    private final String fileExtension;
    private final long fileSize;

    // constructor, toString, equals, hashCode, and getters here.
}

（并填写所有缺少的样板：构造函数、toString、equals、hashCode 和 getters。如果您愿意，请参阅 Project Lombok 的 @Value 以使这变得简单）。您可以使用 

fileName.lastIndexOf('.')
和 
fileName.substring(lastIndex)
从文件名获取文件扩展名。使用 lombok，您只需编写：

@lombok.Value public class FileEquality {
    String fileExtension;
    long fileSize;
}

然后使用 

FileEquality
对象作为哈希图中的键而不是字符串。然而，仅仅因为“foo.txt”和“bar.txt”大小恰好都是 500 字节，并不意味着这两个文件是重复的。因此，您也希望包含内容，但是，如果您扩展 
FileEquality
类以包含文件的内容，则会出现两件事：

  1. 如果您无论如何都要检查内容，那么大小和文件扩展名有什么关系呢？如果 

    foo.txt
    和 
    bar.jpg
    的内容完全相同，那么它们就是重复的，不是吗？何必。您可以将内容传递为 
    byte[]
    ，但请注意，编写适当的 
    hashCode()
    和 
    equals()
    实现（如果您想将此对象用作哈希图的键，则需要这些实现）变得有点棘手。幸运的是，lombok 的 
    @Value
    会正确处理，所以我建议你使用它。

  2. 这意味着文件内容的全部都在 JVM 的进程内存中。除非您要检查非常小的文件，否则您将耗尽内存。您可以通过不存储文件的全部内容，而是存储内容的哈希值来稍微抽象化这一点。谷歌搜索如何在 java 中计算文件的 sha-256 哈希值。将此哈希值放入您的 

    FileEquality
    中，现在您可以避免内存问题。理论上有可能有 2 个内容不同的文件，但它们散列到完全相同的 sha-256 值，但这种可能性是天文数字，更重要的是，sha-256 的设计使得故意在数学上不可行制作 2 个这样的文件来扰乱你的应用程序。因此，我建议你只相信哈希值:)

当然请注意，散列整个文件需要读取整个文件，因此，如果您在包含 500GB 大小的文件的目录上运行重复查找器，那么您的应用程序至少需要读取 500GB，这需要一些时间。

2
投票

我使用 MessageDigest 并检查了一些文件，并根据我在标题和描述中列出的所有标准查找重复项。谢谢大家。

private static MessageDigest messageDigest;
static {
    try {
        messageDigest = MessageDigest.getInstance("SHA-512");
    } catch (NoSuchAlgorithmException e) {
        throw new RuntimeException("cannot initialize SHA-512 hash function", e);
    }
}

这是在重复搜索代码中实现后的结果

public static void find(Map<String, List<String>> lists, File dir) {
for (File f : dir.listFiles()) {
  if (f.isDirectory()) {
    find(lists, f);
  } else {
      try{
          FileInputStream fi = new FileInputStream(f);
          byte fileData[] = new byte[(int) f.length()];
                fi.read(fileData);
                fi.close();
                //Crearea id unic hash pentru fisierul curent
                String hash = new BigInteger(1, messageDigest.digest(fileData)).toString(16);
                List<String> list = lists.get(hash);
                if (list == null) {
                    list = new LinkedList<String>();
                }
                //Adăugați calea către listă
                list.add(f.getAbsolutePath());
                //Adauga lista actualizată la tabelul Hash
                lists.put(hash, list);

      }catch (IOException e) {
                throw new RuntimeException("cannot read file " + f.getAbsolutePath(), e);
            }

  }
}

}

0
投票

我很久以前就制作了这个应用程序，如果你想学习的话，我为你找到了一些源代码。

此方法通过比较两个文件字节来工作。

public static boolean checkBinaryEquality(File file1, File file2) {
    if(file1.length() != file2.length()) return false;
    try(FileInputStream f1 = new FileInputStream(file1); FileInputStream f2 = new FileInputStream(file2)){
            byte bus1[] = new byte[1024],
                 bus2[] = new byte[1024];
            // comparing files bytes one by one if we found unmatched results that means they are not equal
            while((f1.read(bus1)) >= 0) {
                f2.read(bus2);
                for(int i = 0; i < 1024;i++)
                    if(bus1[i] != bus2[i]) 
                        return false;
            }
            // passed
            return true;
    } catch (IOException exp) {
        // problems occurred so let's consider them not equal
        return false;
    }
}

将此方法与名称和扩展名检查结合起来，就可以开始了。

0
投票

复制粘贴示例

  1. 创建一个扩展的类 

    File

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

public class MyFile extends File {
    private static final long serialVersionUID = 1L;

    public MyFile(final String pathname) {
        super(pathname);
    }

    @Override
    public boolean equals(final Object obj) {
        if (this == obj) {
            return true;
        }
        if (this.getClass() != obj.getClass()) {
            return false;
        }
        final MyFile other = (MyFile) obj;
        if (!Arrays.equals(this.getContent(), other.getContent())) {
            return false;
        }
        if (this.getName() == null) {
            if (other.getName() != null) {
                return false;
            }
        } else if (!this.getName().equals(other.getName())) {
            return false;
        }
        if (this.length() != other.length()) {
            return false;
        }
        return true;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = prime;
        result = (prime * result) + Arrays.hashCode(this.getContent());
        result = (prime * result) + ((this.getName() == null) ? 0 : this.getName().hashCode());
        result = (prime * result) + (int) (this.length() ^ (this.length() >>> 32));
        return result;
    }

    private byte[] getContent() {
        try (final FileInputStream fis = new FileInputStream(this)) {
            return fis.readAllBytes();
        } catch (final IOException e) {
            e.printStackTrace();
            return new byte[] {};
        }
    }
}

  2. 读取基本目录

    import java.io.File;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Vector;

public class FileTest {
    public FileTest() {
        super();
    }

    public static void main(final String[] args) {
        final Map<MyFile, List<MyFile>> duplicates = new HashMap<>();
        FileTest.handleDirectory(duplicates, new File("[path to base directory]"));
        final Iterator<Entry<MyFile, List<MyFile>>> iterator = duplicates.entrySet().iterator();
        while (iterator.hasNext()) {
            final Entry<MyFile, List<MyFile>> next = iterator.next();
            if (next.getValue().size() == 0) {
                iterator.remove();
            } else {
                System.out.println(next.getKey().getName() + " - " + next.getKey().getAbsolutePath());
                for (final MyFile file : next.getValue()) {
                    System.out.println("        ->" + file.getName() + " - " + file.getAbsolutePath());
                }
            }
        }
    }

    private static void handleDirectory(final Map<MyFile, List<MyFile>> duplicates, final File directory) {
        final File dir = directory;
        if (dir.isDirectory()) {
            final File[] files = dir.listFiles();
            for (final File file : files) {
                if (file.isDirectory()) {
                    FileTest.handleDirectory(duplicates, file);
                    continue;
                }
                final MyFile myFile = new MyFile(file.getAbsolutePath());
                if (!duplicates.containsKey(myFile)) {
                    duplicates.put(myFile, new Vector<>());
                } else {
                    duplicates.get(myFile).add(myFile);
                }
            }
        }
    }
}
0
投票

这是一种处理 Java 记录的方法。您可以根据您的用例调整 

equals()
和 
hashCode()
的语义。

这个答案的好处是使用 Java 比较器来提高灵活性。正如 @rzwitserloot 所指出的，一个缺点是缺乏构建器支持（您可以根据需要使用来自 Lombok 的 @Builder 对记录进行注释）和在构造时设置值。

import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

public record FileEquality(String name,
                           String fileExtension,
                           long fileSize) implements Comparable<FileEquality> {

    private static final Comparator<FileEquality> COMPARATOR =
            Comparator.comparingLong(FileEquality::fileSize)
                    .thenComparing(FileEquality::fileExtension);
        
    @Override
    public int compareTo(FileEquality other) {
        return COMPARATOR.compare(this, other);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof FileEquality that)) return false;
        return fileSize == that.fileSize &&
                Objects.equals(fileExtension, that.fileExtension);
    }

    @Override
    public int hashCode() {
        return Objects.hash(fileSize, fileExtension);
    }

    public String toString() {
        return "name=" + this.name + ", ext=" + this.fileExtension +
                ", size=" + this.fileSize;
    }
}

您选择如何查找重复项，因为有多种方法：

    public List<FileEquality> findDuplicates(List<FileEquality> fileList) {
        Map<FileEquality, Long> counts = fileList.stream()
                .collect(Collectors.groupingBy(
                        file -> file,
                        Collectors.counting()
                ));

        return counts.entrySet().stream()
                .filter(entry -> entry.getValue() > 1)
                .map(Map.Entry::getKey)
                .collect(Collectors.toList());
    }

并称其为：

    List<FileEquality> duplicates = findDuplicates(equalityList);
    System.out.println("Duplicate files by size and extension:");
    duplicates.forEach(System.out::println);

（在实际代码中使用记录器）。

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.