Was ist der schnellste Hash-Algorithmus, um zu prüfen, ob zwei Dateien gleich sind?

Es sei denn, Sie verwenden eine sehr komplizierte und/oder langsam-hash, wird das laden der Daten von der Festplatte dauert viel länger als das berechnen der hash (es sei denn, Sie verwenden Sie RAM-disks oder top-end-SSDs).

So zum vergleichen von zwei Dateien, die Verwendung dieses Algorithmus:

• Vergleichen Größen
• Vergleichen Sie die Daten (hier vorsichtig sein: so können Sie die falsche Antwort; Sie müssen testen, ob dies bei Ihnen der Fall ist oder nicht)
• Vergleichen der hashes

Diese ermöglicht ein schnelles scheitern (wenn die Größen unterschiedlich sind, Sie wissen, dass die Dateien unterschiedlich sind).

Dinge selbst zu machen und schneller, können Sie berechnen den hash einmal und speichern Sie Sie zusammen mit der Datei. Auch speichern der Datei, Datum und Größe in dieser extra-Datei, so wissen Sie schnell, wenn Sie berechnen den hash oder löschen Sie die hash-Datei, wenn die Haupt-Datei ändert.

InformationsquelleAutor der Antwort Aaron Digulla

Könnten Sie versuchen,MurmurHashdie speziell entwickelt wurde, um schnell und ist ziemlich einfach zu Programmieren. Möchten Sie vielleicht ein zweiter, sicherer hash-wenn MurmurHash returns-ein Spiel obwohl, nur um sicher zu sein.

InformationsquelleAutor der Antwort int3

Wenn es nur ein einmaliger dann gegeben, dass Sie haben zu Lesen, sowohl Dateien, die zum generieren einer hash von beiden, warum nicht Lesen Sie einfach durch eine kleine Menge von jeder an eine Zeit und vergleichen?

Andernfalls CRC ist ein sehr einfacher Algorithmus.

InformationsquelleAutor der Antwort Jeff Foster

Was wir optimieren hier ist die verbrachte Zeit auf eine Aufgabe.
Leider wissen wir nicht genug über die Aufgabe zu wissen, was die optimale Lösung sein sollte.

Ist es für ein-Zeit-Vergleich von 2 beliebigen Dateien?
Dann vergleichen Sie die Größe, und nach, vergleichen Sie einfach die Dateien, byte-by-byte (mb oder mb), wenn das ist besser für Ihre IO.

Wenn es für 2 große Gruppen von Dateien, oder viele Sätze von Dateien, und es ist nicht eine einmalige übung. aber etwas, das passiert Häufig, dann sollte man das speichern von hashes für jede Datei. Ein hash ist nie eindeutig, sondern ein hash mit einer Zahl, sagen wir 9 stellen (mit 32 bits) wäre gut für über 4 Milliarden Kombination, und eine 64-bit Zahl wäre gut genug, um zu unterscheiden zwischen etwa 16 * 10^18 Trillionen verschiedene Dateien.

Einen anständigen Kompromiss wäre zum generieren 2 32-bit-hashes für jede Datei, die man für die ersten 8k, eine für 1MB+8k, Schlag Sie zusammen als eine einzelne 64-bit-Zahl. Katalogisieren Sie alle vorhandenen Dateien in eine DB sein sollte, ziemlich schnell und sucht sich ein Kandidat Datei mit dieser DB sollte auch sehr schnell sein. Sobald eine übereinstimmung vorhanden ist, der einzige Weg, um festzustellen, ob Sie identisch sind, ist zu vergleichen mit den ganzen Dateien.

Ich bin ein Gläubiger in den Menschen, was Sie brauchen, was nicht immer nie, was Sie denken, Sie brauchen, oder was die wollen.

InformationsquelleAutor der Antwort bjorn

Der folgende code ist der code um doppelte Dateien zu finden aus meinem persönlichen Projekt zu Sortieren Bilder, die auch entfernt die Duplikate. Nach meiner Erfahrung, zuerst mit schnell hashing algo wie CRC32 und dann tut MD5-oder SHA1-war sogar noch langsamer und hat nicht gemacht, auch keine Verbesserung, da die meisten von den Dateien mit gleichen Größen waren in der Tat doppelt so ausgeführt hashing zweimal wurde teurer von cpu-Zeit-Perspektive, dieser Ansatz kann nicht richtig sein für alle Art von Projekten, aber es ist definitiv wahr für image-Dateien. Hier bin ich tun, MD5-oder SHA1-Hash nur auf die Dateien mit derselben Größe.

PS: Es hängt davon ab, Apache commons codec zum generieren von hash-effizient.

Beispiel für die Nutzung: neue DuplicateFileFinder("MD5").findDuplicateFilesList(filesList);

    import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Map;

    import org.apache.commons.codec.digest.DigestUtils;

    /**
     * Finds the duplicate files using md5/sha1 hashing, which is used only for the sizes which are of same size.
     *  
     * @author HemantSingh
     *
     */
    public class DuplicateFileFinder {

        private HashProvider hashProvider;
        //Used only for logging purpose.
        private String hashingAlgo;

        public DuplicateFileFinder(String hashingAlgo) {
            this.hashingAlgo = hashingAlgo;
            if ("SHA1".equalsIgnoreCase(hashingAlgo)) {
                hashProvider = new Sha1HashProvider();
            } else if ("MD5".equalsIgnoreCase(hashingAlgo)) {
                hashProvider = new Md5HashProvider();
            } else {
                throw new RuntimeException("Unsupported hashing algorithm:" + hashingAlgo + " Please use either SHA1 or MD5.");
            }
        }

        /**
         * This API returns the list of duplicate files reference.
         * 
         * @param files
         *            - List of all the files which we need to check for duplicates.
         * @return It returns the list which contains list of duplicate files for
         *         e.g. if a file a.JPG have 3 copies then first element in the list
         *         will be list with three references of File reference.
         */
        public List<List<File>> findDuplicateFilesList(List<File> files) {
            //First create the map for the file size and file reference in the array list.
            Map<Long, List<File>> fileSizeMap = new HashMap<Long, List<File>>();
            List<Long> potDuplicateFilesSize = new ArrayList<Long>();

            for (Iterator<File> iterator = files.iterator(); iterator.hasNext();) {
                File file = (File) iterator.next();
                Long fileLength = new Long(file.length());
                List<File> filesOfSameLength = fileSizeMap.get(fileLength);
                if (filesOfSameLength == null) {
                    filesOfSameLength = new ArrayList<File>();
                    fileSizeMap.put(fileLength, filesOfSameLength);
                } else {
                    potDuplicateFilesSize.add(fileLength);
                }
                filesOfSameLength.add(file);
            }

            //If we don't have any potential duplicates then skip further processing.
            if (potDuplicateFilesSize.size() == 0) {
                return null;
            }

            System.out.println(potDuplicateFilesSize.size() + " files will go thru " + hashingAlgo + " hash check to verify if they are duplicate.");

            //Now we will scan the potential duplicate files, and eliminate false positives using md5 hash check.
            List<List<File>> finalListOfDuplicates = new ArrayList<List<File>>();
            for (Iterator<Long> potDuplicatesFileSizeIterator = potDuplicateFilesSize
                    .iterator(); potDuplicatesFileSizeIterator.hasNext();) {
                Long fileSize = (Long) potDuplicatesFileSizeIterator.next();
                List<File> potDupFiles = fileSizeMap.get(fileSize);
                Map<String, List<File>> trueDuplicateFiles = new HashMap<String, List<File>>();
                for (Iterator<File> potDuplicateFilesIterator = potDupFiles.iterator(); potDuplicateFilesIterator
                        .hasNext();) {
                    File file = (File) potDuplicateFilesIterator.next();
                    try {
                        String md5Hex = hashProvider.getHashHex(file);
                        List<File> listOfDuplicatesOfAFile = trueDuplicateFiles.get(md5Hex);
                        if (listOfDuplicatesOfAFile == null) {
                            listOfDuplicatesOfAFile = new ArrayList<File>();
                            trueDuplicateFiles.put(md5Hex, listOfDuplicatesOfAFile);
                        }
                        listOfDuplicatesOfAFile.add(file);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                Collection<List<File>> dupsOfSameSizeList = trueDuplicateFiles.values();
                for (Iterator<List<File>> dupsOfSameSizeListIterator = dupsOfSameSizeList.iterator(); dupsOfSameSizeListIterator
                        .hasNext();) {
                    List<File> list = (List<File>) dupsOfSameSizeListIterator.next();
                    //It will be duplicate only if we have more then one copy of it.
                    if (list.size() > 1) {
                        finalListOfDuplicates.add(list);
                        System.out.println("Duplicate sets found: " + finalListOfDuplicates.size());
                    }
                }
            }

            return finalListOfDuplicates;
        }

        abstract class HashProvider {
            abstract String getHashHex(File file) throws IOException ;
        }

        class Md5HashProvider extends HashProvider {
            String getHashHex(File file) throws IOException {
                return DigestUtils.md5Hex(new FileInputStream(file));
            }
        }
        class Sha1HashProvider extends HashProvider {
            String getHashHex(File file) throws IOException {
                return DigestUtils.sha1Hex(new FileInputStream(file));
            }
        }
    }

InformationsquelleAutor der Antwort Hemant