手动实现 git 的 git diff 功能

这是 git diff 后的效果，感觉挺简单的，不就是 比较新旧版本，新增了就用 "+" 显示新加一行，删除了就用 "-" 显示删除一行，修改了一行就用 "-"、"+" 显示将旧版本中的该行干掉了并且新版本中增加了一行，即使用 "删除" + "新增" 操作代替 "修改" 操作，然后就用

然后我们写的测试代码如下：

import com.goldwind.ipark.common.util.MyStringUitls;
import org.apache.commons.text.similarity.LevenshteinDistance;

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.List;



public class MyDiffTest {

    public static void main(String[] args) {
        List lines_old = loadTxtFile2List("C:\\E\\javaCode\\git\\outer_project\\guodiantou\\gdtipark-user-servie\\src\\main\\java\\com\\goldwind\\ipark\\base\\test\\DemoClass1.java" );
        List lines_new = loadTxtFile2List("C:\\E\\javaCode\\git\\outer_project\\guodiantou\\gdtipark-user-servie\\src\\main\\java\\com\\goldwind\\ipark\\base\\test\\DemoClass2.java");
        // lines1的起始行和 lines2 的起始行做映射

        // 扫描旧版本中的每一行
        int size = lines_old.size();
        for( int i=0;i loadTxtFile2List(String filePath) {
        BufferedReader reader = null;
        List lines = new ArrayList<>();
        try {
            reader = new BufferedReader(new FileReader(filePath));
            String line = reader.readLine();
            while (line != null) {
                // System.out.println(line);
                lines.add( line );
                line = reader.readLine();
            }
            return lines;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

其中用到的2个新旧版本的文本如下：

DemoClass1.java：

import com.goldwind.ipark.common.exception.BusinessLogicException;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.text.similarity.LevenshteinDistance;

@Slf4j
public class DemoClass1 {

    private static final LevenshteinDistance LEVENSHTEIN_DISTANCE = LevenshteinDistance.getDefaultInstance();

    public static String null2emptyWithTrim( String str ){
        if( str == null ){
            str = "";
        }
        str = str.trim();
        return str;
    }

    public static String requiredStringParamCheck(String param, String paramRemark) {
        param = null2emptyWithTrim( param );
        if( param.length() == 0 ){
            String msg = "操作失败，请求参数 \"" + paramRemark + "\" 为空";
            log.error( msg );
            throw new BusinessLogicException( msg );
        }
        return param;
    }

    public static double calculateSimilarity( String str1,String str2 ){
        int distance = LEVENSHTEIN_DISTANCE.apply(str1, str2);
        double similarity = 1 - (double) distance / Math.max(str1.length(), str2.length());
        System.out.println("相似度：" + similarity);
        return similarity;
    }
}

DemoClass2.java：

import com.goldwind.ipark.common.exception.BusinessLogicException;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.text.similarity.LevenshteinDistance;

@Slf4j
public class DemoClass2 {

    private static final LevenshteinDistance LEVENSHTEIN_DISTANCE = LevenshteinDistance.getDefaultInstance();
    private static final LevenshteinDistance LEVENSHTEIN_DISTANCE1 = LevenshteinDistance.getDefaultInstance();
    private static final LevenshteinDistance LEVENSHTEIN_DISTANCE2 = LevenshteinDistance.getDefaultInstance();

    public static String null2emptyWithTrim( String str ){
        if( str == null ){
            str = "";
        }
        str = str.trim();
        return str;
    }

    public static String requiredStringParamCheck(String param, String paramRemark) {
        param = null2emptyWithTrim( param );
        if( param.length() == 0 ){
            String msg = "操作失败，请求参数 \"" + paramRemark + "\" 为空";
            log.error( msg );
            throw new BusinessLogicException( msg );
        }
        return param;
    }

    public static double calculateSimilarity( String str1,String str2 ){
        int distance = LEVENSHTEIN_DISTANCE.apply(str1, str2);
        double similarity = 1 - (double) distance / Math.max(str1.length(), str2.length());
        System.out.println("相似度：" + similarity);
        return similarity;
    }
}

DemoClass2.java 相较于 DemoClass1.java 的区别是 "public class" 后面的类名不同，"private static final LevenshteinDistance LEVENSHTEIN_DISTANC..." 多复制了2行并改了名称，然后运行后显示差别如下：

import com.goldwind.ipark.common.exception.BusinessLogicException;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.text.similarity.LevenshteinDistance;

@Slf4j
- public class DemoClass1 {
+ public class DemoClass2 {

    private static final LevenshteinDistance LEVENSHTEIN_DISTANCE = LevenshteinDistance.getDefaultInstance();
- 
+     private static final LevenshteinDistance LEVENSHTEIN_DISTANCE1 = LevenshteinDistance.getDefaultInstance();
-     public static String null2emptyWithTrim( String str ){
+     private static final LevenshteinDistance LEVENSHTEIN_DISTANCE2 = LevenshteinDistance.getDefaultInstance();
-         if( str == null ){
+ 
-             str = "";
+     public static String null2emptyWithTrim( String str ){
-         }
+         if( str == null ){
-         str = str.trim();
+             str = "";
-         return str;
+         }
-     }
+         str = str.trim();
- 
+         return str;
-     public static String requiredStringParamCheck(String param, String paramRemark) {
+     }
-         param = null2emptyWithTrim( param );
+ 
-         if( param.length() == 0 ){
+     public static String requiredStringParamCheck(String param, String paramRemark) {
-             String msg = "操作失败，请求参数 \"" + paramRemark + "\" 为空";
+         param = null2emptyWithTrim( param );
-             log.error( msg );
+         if( param.length() == 0 ){
-             throw new BusinessLogicException( msg );
+             String msg = "操作失败，请求参数 \"" + paramRemark + "\" 为空";
-         }
+             log.error( msg );
-         return param;
+             throw new BusinessLogicException( msg );
-     }
+         }
- 
+         return param;
-     public static double calculateSimilarity( String str1,String str2 ){
+     }
-         int distance = LEVENSHTEIN_DISTANCE.apply(str1, str2);
+ 
-         double similarity = 1 - (double) distance / Math.max(str1.length(), str2.length());
+     public static double calculateSimilarity( String str1,String str2 ){
-         System.out.println("相似度：" + similarity);
+         int distance = LEVENSHTEIN_DISTANCE.apply(str1, str2);
-         return similarity;
+         double similarity = 1 - (double) distance / Math.max(str1.length(), str2.length());
-     }
+         System.out.println("相似度：" + similarity);
- }
+         return similarity;

为啥？？？

如上两张图片，旧版本的第10行和新版本的第10行对应，从直观上看新版本的第11、12行是在旧版本的第10行和第11行之间插进去的，但是程序并不这么认为，它会认为将旧版本的第11行的空白行修改为了新版本的 “private static final LevenshteinDistance LEVENSHTEIN_DISTANCE1 = LevenshteinDistance.getDefaultInstance();” 为什么我们人眼会这么直观的感觉到 新版本的 第11、12行时插进去的，因为我们比较了新旧版本的第7、8、9、10行都差不多，旧版本的11~27行和新版本的 13~29行都差不多，所以自然而然的认为新版本的11、12行是直接插进去的，那么现在我们就来算法实现吧！（ ps：前文中的 “差不多” 是差几多？是完全equals 还是很像？”其实这里可以设置一个阈值，使用求字符串的相似度算法求出相似度，网上有现成的类库求相似度，自己也可以使用动态规划写一个简单的字符串相似度算法 ）

感觉恰当的算法的执行过程应该是这样的：

新旧版本各维持一个行号游标：index_old、index_new，最开始这两个游标相同，越往后可能不同，但是他们表示的行的内容应该是应该相似的，因为新版本的修改会导致内容越来越 “错位”。假设我们从上面2张图片的第7行开始描：

        1. 最开始 index_old = index_new = 7，算法检测到新旧版本的第7行的内容相同( 后面我们就尽量用伪代码表示，就不说这么多啰里啰嗦的话了 )，即 lines_old[ 7] = lines_new[ 7]。

        2. index_old++，index_new++，都变为8，算法检测到 lines_old[ 8 ] != lines_new[ index_new ]，并且他们的相似度很高，所以算法判断新版本的第8行相较于旧版本的第8行是做了修改操作。

        3. index_old++，index_new++，都变为9，算法检测到 lines_old[ 9 ] = lines_new[ 9 ]。

        4. index_old++，index_new++，都变为10，算法检测到 lines_old[ 10 ] = lines_new[ 10 ]。

        5.  index_old++，index_new++，都变为11，算法检测到 lines_old[ 11 ] !=  lines_new[ 11 ]，并且这两行的文本内容及不相似，所以判断新版本是在旧版本的第11行插入了一行 “private static final LevenshteinDistance LEVENSHTEIN_DISTANCE1 =LevenshteinDistance.getDefaultInstance();”，所以此时旧版本的第11行就和新版本的第11行对应不上了，而是和新版本的第12行做对应。

        6.  index_old 不变，index_new++，index_old 还是11，index_new 变为 12，即旧版本的第11行要和新版本的第12行做对应，就像找老婆一样，旧7和新7结为了夫妻，旧8和新8结为了夫妻( 虽然有一点点的裂痕，但不打紧 )，新9和新9结为了夫妻，...，所以旧11也要在新版本中找到一个新x作为自己的伴侣，本来已经找到了一个新11，但是发现新11和自己三观差别很大，根本合不来，所以pass掉，继续找，现在发现了下一个相亲对象 新12，发现lines_old[ 11 ] 和 lines_new[ 12 ] 相似度还是差别很大，所以算法判断新版本又插入了一个新行 “private static final LevenshteinDistance LEVENSHTEIN_DISTANCE2 = LevenshteinDistance.getDefaultInstance();”。

        7. index_old 不变，index_new++，index_old 还是11，index_new 变为 13，因为 lines_old[ 11 ] = lines_new[ 13 ],所以 旧11 很幸运的找到了自己的伴侣 新13,。

        8.  index_old++，index_new++，index_old变为12，index_new变为14，因为 lines_old[ 12 ] = lines_new[ 14 ],所以此步未检测到变化。

        ...

改进后的测试代码如下：

todo