Java-使用哈希和数组匹配的两个文件比较

我试图比较两个基于md5散列和数组匹配的文件，以获得性能高效的过程。如果两个字节值都匹配，则两个文件的内容相同，否则将移动到“数组匹配”以找出两个文件之间的差异。我在这里面临的问题是，同一个文件的字节值不同，所以它正在移动到数组匹配，在这种情况下，这是不必要的

Java代码：

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.concurrent.TimeUnit;
import java.security.DigestInputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class CompareTwoFiles {
    static int count1 = 0 ;
    static int count2 = 0 ;

    static String arrayLines1[] = new String[countLines("\\Files_Comparison\\File11.txt")];
    static String arrayLines2[] = new String[countLines("\\Files_Comparison\\File12.txt")];

    public static void main(String args[]) throws Throwable{  
        long lStartTime = new Date().getTime();
        System.out.println("File1 count=" + countLines("\\Files_Comparison\\File11.txt"));
        System.out.println("File2 count=" + countLines("\\Files_Comparison\\File12.txt"));
        MessageDigest md_1 = MessageDigest.getInstance("MD5");
        MessageDigest md_2 = MessageDigest.getInstance("MD5");
        InputStream is_1 = new FileInputStream("\\Files_Comparison\\File11.txt");
        InputStream is_2 = new FileInputStream("\\Files_Comparison\\File12.txt");
        try {
          is_1 = new DigestInputStream(is_1, md_1);
          is_2 = new DigestInputStream(is_2, md_2);
        }
        finally {
          is_1.close();
          is_2.close();
        }
        byte[] digest_1 = md_1.digest();
        byte[] digest_2 = md_2.digest();
        System.out.println(digest_1);
        System.out.println(digest_2);
        if (digest_1.equals(digest_2)) {
            System.out.println("File Comparison Process Completed");
            System.out.println("Both files are same");
        }
        else 
        {
        findDifference("\\Files_Comparison\\File11.txt","\\Files_Comparison\\File12.txt");
        displayRecords();
        System.out.println("File Comparison Process Completed");
        }
        long lEndTime = new Date().getTime();
        long difference = lEndTime - lStartTime; 
        String hms = String.format("%02d:%02d:%02d", TimeUnit.MILLISECONDS.toHours(difference),
                TimeUnit.MILLISECONDS.toMinutes(difference) - TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(difference)),
                TimeUnit.MILLISECONDS.toSeconds(difference) - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(difference)));
        System.out.println(hms);
    }

    public static int countLines(String File){

        int lineCount = 0;
        try {
           BufferedReader br = new BufferedReader(new FileReader(File));
           while ((br.readLine()) != null) {
               lineCount++;
           }

       } catch (FileNotFoundException e) {
           e.printStackTrace();
       } catch (IOException e) {
           e.printStackTrace();
       }
           return lineCount;
    }

    public static void findDifference(String File1, String File2){
        String contents1 = null;  
        String contents2 = null; 
        try  
        {  
            FileReader file1 = new FileReader(File1);  
            FileReader file2 = new FileReader(File2);
            BufferedReader buf1 = new BufferedReader(file1); 
            BufferedReader buf2 = new BufferedReader(file2);

           while ((contents1 = buf1.readLine()) != null)  
            {  
               arrayLines1[count1] = contents1 ;
               count1++;
            }  

           while ((contents2 = buf2.readLine()) != null)  
            {  
               arrayLines2[count2] = contents2 ;
               count2++;
            }
       }catch (Exception e){
           e.printStackTrace();
       }
}





    public static void displayRecords() { 

        for (int i = 0 ; i < arrayLines1.length && i < arrayLines2.length; i++) 
        {    
            String a = arrayLines1[i];  
            String b = arrayLines2[i];  

            if(!a.contains(b)) {  
                   System.out.println(a);  
            }  
        }
    }

}

导入java.io.BufferedReader；
导入java.io.FileInputStream；
导入java.io.FileNotFoundException；
导入java.io.FileReader；
导入java.io.IOException；
导入java.io.InputStream；
导入java.util.Date；
导入java.util.concurrent.TimeUnit；
导入java.security.DigestInputStream；
导入java.security.MessageDigest；
导入java.security.NoSuchAlgorithmException；
公共类比较文件{
静态int count1=0；
静态整数计数2=0；
静态字符串arrayLines1[]=新字符串[countLines（\\Files\u Comparison\\File11.txt”）；
静态字符串arrayLines2[]=新字符串[计数行（\\Files\u Comparison\\File12.txt”）；
公共静态void main（字符串args[]）抛出可丢弃的{
long lstartime=new Date（）.getTime（）；
System.out.println（“File1 count=“+countLines（\\Files\u Comparison\\File11.txt”）；
System.out.println（“File2 count=“+countLines（\\Files\u Comparison\\File12.txt”）；
MessageDigest md_1=MessageDigest.getInstance（“MD5”）；
MessageDigest md_2=MessageDigest.getInstance（“MD5”）；
InputStream为新文件InputStream（\\Files\u Comparison\\File11.txt）；
InputStream是_2=新文件InputStream（\\Files\u Comparison\\File12.txt”）；
试一试{
is_1=新的DigestInputStream（is_1，md_1）；
is_2=新的DigestInputStream（is_2，md_2）；
}
最后{
is_1.close（）；
is_2.close（）；
}
字节[]digest_1=md_1.digest（）；
字节[]digest_2=md_2.digest（）；
系统输出打印LN（摘要1）；
系统输出打印LN（摘要2）；
如果（摘要_1.等于（摘要_2））{
System.out.println（“文件比较过程完成”）；
System.out.println（“两个文件相同”）；
}
其他的
{
findDifference（“\\Files\u Comparison\\File11.txt”，“\\Files\u Comparison\\File12.txt”）；
显示记录（）；
System.out.println（“文件比较过程完成”）；
}
long lEndTime=new Date（）.getTime（）；
长差=lEndTime-lstartime；
String hms=String.format（“%02d:%02d:%02d”，时间单位为毫秒到小时（差值），
TimeUnit.millides.toMinutes（差）-TimeUnit.HOURS.toMinutes（TimeUnit.millides.toHours（差）），
TimeUnit.millizes.toSeconds（差）-TimeUnit.MINUTES.toSeconds（TimeUnit.millizes.toMinutes（差））；
系统输出打印LN（hms）；
}
公共静态整数计数行（字符串文件）{
int lineCount=0；
试一试{
BufferedReader br=新的BufferedReader（新文件读取器（文件））；
而（（br.readLine（））！=null）{
lineCount++；
}
}catch（filenotfounde异常）{
e、 printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
返回行计数；
}
公共静态void findDifference（字符串文件1、字符串文件2）{
字符串contents1=null；
字符串contents2=null；
尝试
{  
FileReader file1=新的FileReader（file1）；
FileReader file2=新的FileReader（file2）；
BufferedReader buf1=新的BufferedReader（文件1）；
BufferedReader buf2=新的BufferedReader（文件2）；
而（（contents1=buf1.readLine（））！=null）
{  
arrayLines1[count1]=内容1；
count1++；
}  
而（（contents2=buf2.readLine（））！=null）
{  
arrayLines2[count2]=内容2；
count2++；
}
}捕获（例外e）{
e、 printStackTrace（）；
}
}
公共静态void displayRecords（）{
对于（int i=0；i

您可能从中获取了解决方案，但忘记阅读这一行：

 /* Read decorated stream (dis) to EOF as normal... */

---

您必须从DigestInputStream中读取，直到读取整个文件。如果在打开后立即关闭流，它们将完全看不到文件中的任何内容，并且都将返回“完全没有字节”的相同摘要。

可能是您从中获取了解决方案，但忘记阅读这一行：

 /* Read decorated stream (dis) to EOF as normal... */

---

您必须从DigestInputStream中读取，直到读取整个文件。如果您在打开后立即关闭流，它们将完全看不到文件中的任何内容，并且都将返回“完全没有字节”的相同摘要。

感谢您的回复。你分享的帖子真的很有帮助。我可以使用以下代码获得预期的解决方案：

String checksum = DigestUtils.md5Hex(new FileInputStream(filePath));

---

谢谢你的回复。你分享的帖子真的很有帮助。我可以使用以下代码获得预期的解决方案：

String checksum = DigestUtils.md5Hex(new FileInputStream(filePath));