封装一个比较集合的工具类

公司业务需要自己封装的一个工具类

ListUtils

public class ListUtils {
    public ListUtils() {
    }

    public static <T> ListUtils.Differ<T> sameAndDiff(List<T> leftList, List<T> rightList, 
DiffDataAdapter<T> diffDataAdapter) {
        ListUtils.Differ<T> differ = new ListUtils.Differ();
        List<T> identicalList = new ArrayList();
        List<T> leftDiffList = new ArrayList();
        List<T> rightDiffList = new ArrayList();
        if (CollectionUtils.isEmpty(leftList) && CollectionUtils.isEmpty(rightList)) {
            return differ;
        } else {
            Iterator var11;
            Object t;
            if (CollectionUtils.isEmpty(leftList)) {
                var11 = rightList.iterator();

                while(var11.hasNext()) {
                    t = var11.next();
                    diffDataAdapter.onRightDiff(t);
                }

                differ.setRightDiffs(rightList);
                return differ;
            } else if (CollectionUtils.isEmpty(rightList)) {
                var11 = leftList.iterator();

                while(var11.hasNext()) {
                    t = var11.next();
                    diffDataAdapter.onLeftDiff(t);
                }

                differ.setLeftDiffs(leftList);
                return differ;
            } else {
                Map<String, T> rightMap = new ConcurrentHashMap();
                Iterator var8 = rightList.iterator();

                Object left;
                while(var8.hasNext()) {
                    left = var8.next();
                    rightMap.put(diffDataAdapter.renderKey(left), left);
                }

                var8 = leftList.iterator();

                while(var8.hasNext()) {
                    left = var8.next();
                    String key = diffDataAdapter.renderKey(left);
                    if (StringUtils.isEmpty(key)) {
                        diffDataAdapter.onLeftDiff(left);
                        leftDiffList.add(left);
                    } else if (rightMap.containsKey(key)) {
                        diffDataAdapter.onIdentical(left, rightMap.get(key));
                        identicalList.add(left);
                        rightMap.remove(key);
                    } else {
                        diffDataAdapter.onLeftDiff(left);
                        leftDiffList.add(left);
                    }
                }

                if (!rightMap.isEmpty()) {
                    var8 = rightMap.entrySet().iterator();

                    while(var8.hasNext()) {
                        Entry<String, T> entry = (Entry)var8.next();
                        diffDataAdapter.onRightDiff(entry.getValue());
                        rightDiffList.add(entry.getValue());
                    }
                }

                differ.setLeftDiffs(leftDiffList);
                differ.setRightDiffs(rightDiffList);
                differ.setIdenticals(identicalList);
                return differ;
            }
        }
    }

    public static class Differ<T> {
        private List<T> leftDiffs;
        private List<T> rightDiffs;
        private List<T> identicals;

        public Differ() {
        }

        public List<T> getLeftDiffs() {
            return this.leftDiffs;
        }

        public List<T> getRightDiffs() {
            return this.rightDiffs;
        }

        public List<T> getIdenticals() {
            return this.identicals;
        }

        public void setLeftDiffs(List<T> leftDiffs) {
            this.leftDiffs = leftDiffs;
        }

        public void setRightDiffs(List<T> rightDiffs) {
            this.rightDiffs = rightDiffs;
        }

        public void setIdenticals(List<T> identicals) {
            this.identicals = identicals;
        }
    }
}

DiffDataAdapter

public abstract class DiffDataAdapter<T> {
    public DiffDataAdapter() {
    }

    protected String renderKey(T t) {
        String key = this.compareKey(t);
        return key;
    }

    protected abstract String compareKey(T var1);

    protected void onLeftDiff(T left) {
    }

    protected void onRightDiff(T right) {
    }

    protected void onIdentical(T left, T right) {
        if (left != null || right != null) {
            ;
        }
    }
}

• 其他参考资料
  30-seconds-of-java8

• guava 库的工具类

Set<String> result1 = Sets.union(set1, set2);           //并集
Set<String> result2 = Sets.intersection(set1, set2);  //交集
Set<String> result3 = Sets.difference(set1, set2);     //差集 1中有而2中没有的
Set<String> result4 = Sets.symmetricDifference(set1, set2); //相对差集 1中有2中没有 2中有1中没有的 取出来做结果