比较旧字符串语句在新字符串语句中的差异

比较旧字符串语句在新字符串语句中的差异

业务场景

在用户与系统的文字交互场景，系统需保存发布用户的输入语句（语句包含一段或多段），但用户在检查的过程中发现自己之前发布的语句输入错误，故进行修改重新发布，系统此时需记录修改的点（包含删除、修改）；

代码示例

import com.ugi.common.utils.StringUtils;

import java.util.*;

public class LogTest {

    public static void main(String[] args) {
        String statement = "这是测试语句\n" +
                "2、咦，这写的什么东西";
        String oldStatement = "这是测试语句吗\n" +
                "1、为了业务也是拼了";
        getStatementDiff(statement,oldStatement);
    }

    /**
     * (statement,oldStatement),从oldStatement中找出statement中被删除的语句or被修改的字符位置
     * @param statement 当前new语句
     * @param oldStatement 备份的old语句
     */
    private static void getStatementDiff(String statement,String oldStatement){
        String[] newArr = statement.split("\\n");
        String[] oldArr = oldStatement.split("\\n");
        if(statement.equals(oldStatement)){
            return;
        }else {
            // 增量：增量并修改赞不考虑
            // 记录oldStatement被删除的语句
            List<String> delArr = new ArrayList<>();
            // 记录oldStatement被修改的字符位置
            Map<String,Map<Integer,String>> mainRes = new HashMap<>();
            for(String old : oldArr){
                String similar =  getSimilarityByArray(old,newArr);
                if(similar == null){
                    delArr.add(old);
                    continue;
                }
                Map<Integer,String> res = getDiff(similar,old);
                if(res != null){
                    mainRes.put(similar,res);
                }
            }
            System.out.println("被删除的语句：");
            for(String del : delArr){
                System.out.println("del-"+del);
            }
            System.out.println("被修改的语句--下标--字符：");
            for(String mainmap:mainRes.keySet()){
                Map<Integer,String> resa = mainRes.get(mainmap);
                for(Integer i : resa.keySet()){
                    System.out.println(mainmap+":"+i+"-"+resa.get(i));
                }
            }
        }
    }

    /**
     * 从数组中获取与diff相关的字符串
     * @param diff
     * @param mainArr
     * @return
     */
    public static String getSimilarityByArray(String diff,String[] mainArr){
        String result = null;
        for(String main:mainArr){
            float similar = StringUtils.getSimilarityRatio(diff,main);
            if(similar > 60){
                result = main;
                break;
            }
        }
        return result;
    }

    /**
     * (A,B),从B中找出A中没有的多余元素
     * 从diff中找出main中没有的多余元素
     * @param main,数据
     * @param diff,数据
     * @return List<String>
     */
    public static Map<Integer,String> getDiff(String main, String diff){
        if(StringUtils.isEmpty(diff)) {
            return null;
        }
        if(StringUtils.isEmpty(main)) {
            return stringToMap(diff);
        }
        if(diff.equals(main)) {
            return null;
        }
        if(diff.length() == 1 && !main.equals(diff)) {
            return stringToMap(diff);
        }
        String[] mainArr =  main.split("");
        String[] diffArr =  diff.split("");

        Map<String, Integer> map = new HashMap<>();
        for (String m : mainArr) {
            if(StringUtils.isNull(map.get(m))){
                map.put(m, 1);
            }else {
                Integer count = map.get(m);
                map.put(m, count+1);
            }
        }
        // 存储多余的字符和下标，并作为值返回
        Map<Integer,String> resMap = new HashMap<>();
        // 存储与main相同的字符+数量
        Map<String, Integer> diffmap = new HashMap<>();
        // 先将diff在main中没有的字符元素，存入resMap
        for (int i=0;i<diffArr.length;i++) {
            if( !map.containsKey(diffArr[i])) {
                resMap.put(i,diffArr[i]);
            }else {
                if(StringUtils.isNull(diffmap.get(diffArr[i]))){
                    diffmap.put(diffArr[i], 1);
                }else {
                    Integer count = diffmap.get(diffArr[i]);
                    diffmap.put(diffArr[i], count+1);
                }
            }
        }

        // 再将diff在main中相同字符的数量差存入submap
        Map<String, Integer> submap = new HashMap<>();
        for(String key : diffmap.keySet()){
            Integer mainCount = map.get(key);
            Integer diffCount = diffmap.get(key);
            if(mainCount != null && mainCount >= diffCount ){
                continue;
            }else {
                submap.put(key, diffCount-mainCount);
            }
        }

        // 最后submap中的字符元素，通过前后字符叠加，与mian匹配判断，获取diff中多余项
        for(String subkey : submap.keySet()){
            Integer subCount = submap.get(subkey);
            int indexFlag = 0;
            for(int j=0;j<subCount;j++){
                int subIndex =  diff.indexOf(subkey,indexFlag);
                String sub = "";
                if(subIndex != 0){
                    sub = diffArr[subIndex-1]+diffArr[subIndex];
                }else {
                    sub = diffArr[subIndex]+diffArr[subIndex+1];
                }
                if(!main.contains(sub)){
                    resMap.put(subIndex,diffArr[subIndex]);
                }
                indexFlag = subIndex;
            }
        }
        return resMap;
    }

    private static Map<Integer,String> stringToMap(String msg){
        Map<Integer,String> stringMap = new HashMap<>();
        char[] msgArr =  msg.toCharArray();
        for(int i=0;i<msgArr.length;i++){
            stringMap.put(i,String.valueOf(msgArr[i]));
        }
        return stringMap;
    }
}

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 字符串工具类
 * 
 * @author twb
 */
public class StringUtils extends org.apache.commons.lang3.StringUtils
{
    /** 空字符串 */
    private static final String NULLSTR = "";

    /** 下划线 */
    private static final char SEPARATOR = '_';

    /**
     * 获取参数不为空值
     * 
     * @param value defaultValue 要判断的value
     * @return value 返回值
     */
    public static <T> T nvl(T value, T defaultValue)
    {
        return value != null ? value : defaultValue;
    }

    /**
     * * 判断一个Collection是否为空， 包含List，Set，Queue
     * 
     * @param coll 要判断的Collection
     * @return true：为空 false：非空
     */
    public static boolean isEmpty(Collection<?> coll)
    {
        return isNull(coll) || coll.isEmpty();
    }

    /**
     * * 判断一个Collection是否非空，包含List，Set，Queue
     * 
     * @param coll 要判断的Collection
     * @return true：非空 false：空
     */
    public static boolean isNotEmpty(Collection<?> coll)
    {
        return !isEmpty(coll);
    }

    /**
     * * 判断一个对象数组是否为空
     * 
     * @param objects 要判断的对象数组
     ** @return true：为空 false：非空
     */
    public static boolean isEmpty(Object[] objects)
    {
        return isNull(objects) || (objects.length == 0);
    }

    /**
     * * 判断一个对象数组是否非空
     * 
     * @param objects 要判断的对象数组
     * @return true：非空 false：空
     */
    public static boolean isNotEmpty(Object[] objects)
    {
        return !isEmpty(objects);
    }

    /**
     * * 判断一个Map是否为空
     * 
     * @param map 要判断的Map
     * @return true：为空 false：非空
     */
    public static boolean isEmpty(Map<?, ?> map)
    {
        return isNull(map) || map.isEmpty();
    }

    /**
     * * 判断一个Map是否为空
     * 
     * @param map 要判断的Map
     * @return true：非空 false：空
     */
    public static boolean isNotEmpty(Map<?, ?> map)
    {
        return !isEmpty(map);
    }

    /**
     * * 判断一个字符串是否为空串
     * 
     * @param str String
     * @return true：为空 false：非空
     */
    public static boolean isEmpty(String str)
    {
        return isNull(str) || NULLSTR.equals(str.trim());
    }

    /**
     * * 判断一个字符串是否为非空串
     * 
     * @param str String
     * @return true：非空串 false：空串
     */
    public static boolean isNotEmpty(String str)
    {
        return !isEmpty(str);
    }

    /**
     * * 判断一个对象是否为空
     * 
     * @param object Object
     * @return true：为空 false：非空
     */
    public static boolean isNull(Object object)
    {
        return object == null;
    }

    /**
     * * 判断一个对象是否非空
     * 
     * @param object Object
     * @return true：非空 false：空
     */
    public static boolean isNotNull(Object object)
    {
        return !isNull(object);
    }

    /**
     * 获取两个字符串的相关度
     * @param str 待比较字符串
     * @param target 目标字符串
     * @return
     */
    public static float getSimilarityRatio(String str, String target) {

        int d[][]; // 矩阵
        int n = str.length();
        int m = target.length();
        int i; // 遍历str的
        int j; // 遍历target的
        char ch1; // str的
        char ch2; // target的
        int temp; // 记录相同字符,在某个矩阵位置值的增量,不是0就是1
        if (n == 0 || m == 0) {
            return 0;
        }
        d = new int[n + 1][m + 1];
        for (i = 0; i <= n; i++) { // 初始化第一列
            d[i][0] = i;
        }

        for (j = 0; j <= m; j++) { // 初始化第一行
            d[0][j] = j;
        }

        for (i = 1; i <= n; i++) { // 遍历str
            ch1 = str.charAt(i - 1);
            // 去匹配target
            for (j = 1; j <= m; j++) {
                ch2 = target.charAt(j - 1);
                if (ch1 == ch2 || ch1 == ch2 + 32 || ch1 + 32 == ch2) {
                    temp = 0;
                } else {
                    temp = 1;
                }
                // 左边+1,上边+1, 左上角+temp取最小
                d[i][j] = Math.min(Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1), d[i - 1][j - 1] + temp);
            }
        }

        return (1 - (float) d[n][m] / Math.max(str.length(), target.length())) * 100F;
    }
}

运行结果如下，输出的是，被删除的语句和备份语句中被修改的字符和下标：