Question

我编写了一个文件dupelication处理器，它获取每个文件的MD5哈希值，将其添加到哈希映射中，而不是将所有具有相同哈希值的文件添加到名为dupeList的哈希映射中。但是在运行大型目录进行扫描时，例如C：\ Program Files \，它将引发以下错误

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
at java.nio.file.Files.read(Unknown Source)
at java.nio.file.Files.readAllBytes(Unknown Source)
at com.embah.FileDupe.Utils.FileUtils.getMD5Hash(FileUtils.java:14)
at com.embah.FileDupe.FileDupe.getDuplicateFiles(FileDupe.java:43)
at com.embah.FileDupe.FileDupe.getDuplicateFiles(FileDupe.java:68)
at ImgHandler.main(ImgHandler.java:14)

我确定它是因为它处理了这么多文件，但我不确定是否有更好的方法来处理它。我试图让这个工作，所以我可以通过我所有的孩子筛选和删除dupelicates之前我把它们放在我的外部硬盘上进行长期存储。谢谢大家的帮助！

我的代码

public class FileUtils {
public static String getMD5Hash(String path){
    try {
        byte[] bytes = Files.readAllBytes(Paths.get(path)); //LINE STACK THROWS ERROR
        byte[] hash = MessageDigest.getInstance("MD5").digest(bytes);
        bytes = null;
        String hexHash = DatatypeConverter.printHexBinary(hash);
        hash = null;
        return hexHash;
    } catch(Exception e){
        System.out.println("Having problem with file: " + path);
        return null;
    }
}

public class FileDupe {
public static Map<String, List<String>> getDuplicateFiles(String dirs){
    Map<String, List<String>> allEntrys = new HashMap<>(); //<hash, file loc>
    Map<String, List<String>> dupeEntrys = new HashMap<>();
    File fileDir = new File(dirs);
    if(fileDir.isDirectory()){
        ArrayList<File> nestedFiles = getNestedFiles(fileDir.listFiles());
        File[] fileList = new File[nestedFiles.size()];
        fileList = nestedFiles.toArray(fileList);

        for(File file:fileList){
            String path = file.getAbsolutePath();
            String hash = "";
            if((hash = FileUtils.getMD5Hash(path)) == null)
                continue;
            if(!allEntrys.containsValue(path))
                put(allEntrys, hash, path);
        }
        fileList = null;
    }
    allEntrys.forEach((hash, locs) -> {
        if(locs.size() > 1){
            dupeEntrys.put(hash, locs);
        }
    });
    allEntrys = null;
    return dupeEntrys;
}

public static Map<String, List<String>> getDuplicateFiles(String... dirs){
    ArrayList<Map<String, List<String>>> maps = new ArrayList<Map<String, List<String>>>();
    Map<String, List<String>> dupeMap = new HashMap<>();
    for(String dir : dirs){ //Get all dupe files
        maps.add(getDuplicateFiles(dir));
    }
    for(Map<String, List<String>> map : maps){ //iterate thru each map, and add all items not in the dupemap to it
        dupeMap.putAll(map);
    }
    return dupeMap;
}

protected static ArrayList<File> getNestedFiles(File[] fileDir){
    ArrayList<File> files = new ArrayList<File>();
    return getNestedFiles(fileDir, files);
}

protected static ArrayList<File> getNestedFiles(File[] fileDir, ArrayList<File> allFiles){
    for(File file:fileDir){
        if(file.isDirectory()){
            getNestedFiles(file.listFiles(), allFiles);
        } else {
            allFiles.add(file);
        }
    }
    return allFiles;
}

protected static <KEY, VALUE> void put(Map<KEY, List<VALUE>> map, KEY key, VALUE value) {
    map.compute(key, (s, strings) -> strings == null ? new ArrayList<>() : strings).add(value);
}


public class ImgHandler {
private static Scanner s = new Scanner(System.in);

public static void main(String[] args){
    System.out.print("Please enter locations to scan for dupelicates\nSeperate Location via semi-colon(;)\nLocations: ");
    String[] locList = s.nextLine().split(";");
    Map<String, List<String>> dupes = FileDupe.getDuplicateFiles(locList);
    System.out.println(dupes.size() + " dupes detected!");
    dupes.forEach((hash, locs) -> {
        System.out.println("Hash: " + hash);
        locs.forEach((loc) -> System.out.println("\tLocation: " + loc));
    });
}

Answer 1

将整个文件读入一个字节数组不仅需要足够的堆空间，它还限制在原则上<{1}} 的文件大小（HotSpot JVM的实际限制是甚至更小的几个字节）。

最好的解决方案是不要将数据加载到堆内存中：

Integer.MAX_VALUE

如果底层public static String getMD5Hash(String path) { MessageDigest md; try { md = MessageDigest.getInstance("MD5"); } catch(NoSuchAlgorithmException ex) { System.out.println("FileUtils.getMD5Hash(): "+ex); return null;// TODO better error handling } try(FileChannel fch = FileChannel.open(Paths.get(path), StandardOpenOption.READ)) { for(long pos = 0, rem = fch.size(), chunk; rem>pos; pos+=chunk) { chunk = Math.min(Integer.MAX_VALUE, rem-pos); md.update(fch.map(FileChannel.MapMode.READ_ONLY, pos, chunk)); } } catch(IOException e){ System.out.println("Having problem with file: " + path); return null;// TODO better error handling } return String.format("%032X", new BigInteger(1, md.digest())); }实现是一个纯Java实现，它会将数据从直接缓冲区传输到堆，但这超出了你的职责范围（这将是消耗堆内存之间的合理权衡）和表现）。

上述方法可以毫无问题地处理超出2GiB大小的文件。

Answer 2

任何实现FileUtils都试图读取整个文件来计算哈希值。这不是必需的：通过读取较小块中的内容可以进行计算。事实上，要求这样做是一种糟糕的设计，而不是简单地读取所需的块（64字节？）。所以也许你需要使用更好的库。

Answer 3

你有很多解决方案：

不要一次读取所有字节，尝试使用BufferedInputStream，每次都读取大量字节。但不是所有文件。

try (BufferedInputStream fileInputStream = new BufferedInputStream( 
        Files.newInputStream(Paths.get("your_file_here"), StandardOpenOption.READ))) {

    byte[] buf = new byte[2048];
    int len = 0;
    while((len = fileInputStream.read(buf)) == 2048) {
        // Add this to your calculation
        doSomethingWithBytes(buf);
    }
    doSomethingWithBytes(buf, len); // Do only with the bytes
                                    // read from the file


} catch(IOException ex) {
    ex.printStackTrace();
}

使用C / C ++来做这件事（好吧，这是不安全的，因为你自己会处理内存）

Answer 4

考虑使用Guava：

    private final static HashFunction HASH_FUNCTION = Hashing.goodFastHash(32);

   //somewhere later

   final HashCode hash = Files.asByteSource(file).hash(HASH_FUNCTION);

Guava将为您缓冲文件的读取。

JVM抛出java.lang.OutOfMemoryError：堆空间（文件处理）

4 个答案: