java 实现Diff算法

作用：比较新旧数组，得到新增的元素，删除的元素，更新的元素

public class DiffUtil {
    @Data
    @Accessors(chain = true)
    public static class DiffResult<T> {
        /**
         * 新增对象列表
         */
        private List<T> addedList;
        /**
         * 修改后的对象列表
         */
        private List<T> changedList;
        /**
         * 已删除对象列表
         */
        private List<T> deletedList;
    }

    /**
     * 对比两个List的元素
     * <p>
     * 如果 baseList 的元素在 targetList 中存在 PrimaryKey 相等的元素并且 elementComparator 比较结果不相等，则将修改后的值添加到changedList列表中；
     * 如果 baseList 的元素在 targetList 中不存在，将baseList中的元素添加到deletedList中；
     * 如果 targetList 的元素在 baseList 中不存在，将targetList中的元素添加到addedList中；
     * <p>
     * complexity: O(n)
     *
     * @param baseList            基础List(原来的List)
     * @param targetList          目标List(最新的List)
     * @param elementComparator   元素比较器
     * @param primaryKeyExtractor 主键选择器
     * @param <T>
     * @return 对比结果
     */
    public static <T> DiffResult<T> diffList(List<T> baseList,
                                             List<T> targetList,
                                             @NotNull Function<T, Object> primaryKeyExtractor,
                                             @NotNull Comparator<T> elementComparator) {

        DiffResult<T> checkResult = checkEmptyAndReturn(baseList, targetList);
        if (checkResult != null) {
            return checkResult;
        }

        Map<Object,T> baseMap = new HashMap<>(4096);
        for(T base : baseList){
            Object key = primaryKeyExtractor.apply(base);
            baseMap.put(key,base);
        }

        List<T> addedList = new ArrayList<>();
        List<T> changedList = new ArrayList<>();
        List<T> deletedList = new ArrayList<>();

        //找出新增的 和需要更新的
        for (T target : targetList) {
            Object key = primaryKeyExtractor.apply(target);
            T base = baseMap.get(key);
            if(base == null){
                addedList.add(target);
            }else{
                baseMap.remove(key);
                if (elementComparator.compare(base, target) != 0) {
                    changedList.add(target);
                }
            }
        }

        //剩余的就是需要删除的
        Set<Map.Entry<Object, T>> entrySet = baseMap.entrySet();
        if(CollectionUtils.isNotEmpty(entrySet)){
            for(Map.Entry<Object, T> entry:entrySet){
                deletedList.add(entry.getValue());
            }
        }

        return new DiffResult<T>()
                .setAddedList(addedList)
                .setChangedList(changedList)
                .setDeletedList(deletedList);
    }


    /**
     * 检查baseList 和 targetList 为empty(null||size==0)的情况
     *
     * @param baseList
     * @param targetList
     * @param <T>
     * @return
     */
    private static <T> DiffResult<T> checkEmptyAndReturn(List<T> baseList, List<T> targetList) {

        if (CollectionUtils.isEmpty(baseList) && CollectionUtils.isEmpty(targetList)) {
            return new DiffResult<T>()
                    .setAddedList(null)
                    .setChangedList(null)
                    .setDeletedList(null);
        }

        if (CollectionUtils.isEmpty(baseList) && CollectionUtils.isNotEmpty(targetList)) {
            return new DiffResult<T>()
                    .setAddedList(targetList)
                    .setChangedList(null)
                    .setDeletedList(null);
        }

        if (CollectionUtils.isNotEmpty(baseList) && CollectionUtils.isEmpty(targetList)) {
            return new DiffResult<T>()
                    .setAddedList(null)
                    .setChangedList(null)
                    .setDeletedList(baseList);
        }
        return null;
    }

    @Data
    @AllArgsConstructor
    public static class User {
        private Integer id;
        private String userName;
        private String realName;
    }

案列：
 @Test
    void test04(){
        List<DiffUtil.User> baseList=new ArrayList<>();
        List<DiffUtil.User> targetList=new ArrayList<>();
        DiffUtil.User user=new DiffUtil.User(1,"a","b");
        DiffUtil.User user1=new DiffUtil.User(2,"a","b");
        baseList.add(user);
        baseList.add(user1);
        DiffUtil.User user2=new DiffUtil.User(3,"a","b");
        DiffUtil.User user3=new DiffUtil.User(4,"a","b");
        DiffUtil.User user4=new DiffUtil.User(1,"abb","bbbb");

        targetList.add(user4);
        targetList.add(user2);
        targetList.add(user3);
        // 主键选择器
        Function<DiffUtil.User,Object> function=mbi-> mbi.getId();
        // 元素比较器
        DiffUtil.DiffResult<DiffUtil.User>  result= DiffUtil.diffList(baseList,targetList,function,new Comparator<DiffUtil.User>(){
            @Override
            public int compare(DiffUtil.User o1, DiffUtil.User o2) {
                int i = 0;
                // 自定義比較規則,帥選出更新的元素
                if (o1.getUserName().equals(o2.getUserName())){
                    i=0;
                }else {
                    i=1;
                }
                return i;

            }
        });

        System.out.println(result.getAddedList());
        System.out.println(result.getDeletedList());
        System.out.println(result.getChangedList());
        
        // 通過以下操作可得到最終更新後的新數組
        baseList.addAll(result.getAddedList());
        baseList.removeAll(result.getDeletedList());
        baseList.forEach(mbi->{
            for (DiffUtil.User obj:result.getChangedList()){
                if (mbi.getId()==obj.getId()){
                   mbi.setRealName(obj.getRealName());
                   mbi.setUserName(obj.getUserName());
                }
            }
        });
        System.out.println(baseList);
    }