java求两个集合的addList,updateList,delList

java求两个集合的addList,updateList,delList

public class CollectionCompareLite<N, O, T> {

    static enum PropertyChangeType {
        ADDED,
        MODIFIED,
        DELETED
    }

    private Map<PropertyChangeType, List<T>> compareMap;

    private Integer newCollectionSize;

    private Integer oldCollectionSize;

    private Boolean diff;

    public CollectionCompareLite(Collection<N> newCollection, Collection<O> oldCollection, Function<N, T> firstField,
                                 Function<O, T> secondField) {
        compare(newCollection, oldCollection, firstField, secondField);
    }

    public CollectionCompareLite(List<N> newList, List<N> oldList) {
        compare(newList, (Collection) oldList, Function.identity(), Function.identity());
    }

    public CollectionCompareLite(Set<N> newList, Set<N> oldList) {
        compare((Collection) newList, (Collection) oldList, Function.identity(), Function.identity());
    }

    private <T> Map<Integer, List<T>> compare(Collection<N> newCollection, Collection<O> oldCollection,
                                              Function firstProp, Function secondProp) {

        Collection<T> newList = (Collection<T>) Optional.ofNullable(newCollection)
                .orElse(CollectionUtils.emptyCollection()).stream().map(firstProp).distinct()
                .collect(Collectors.toList());

        Collection<T> oldList = (Collection<T>) Optional.ofNullable(oldCollection)
                .orElse(CollectionUtils.emptyCollection()).stream().map(secondProp).distinct()
                .collect(Collectors.toList());

        setCompareCollectionSize(newList.size(), oldList.size());

        Collection<T> insert = CollectionUtils.removeAll(newList, oldList);
        Collection<T> delete = CollectionUtils.removeAll(oldList, newList);
        Collection<T> update = CollectionUtils.retainAll(newList, oldList);

        List addList = Lists.newArrayList(insert);
        List deleteList = Lists.newArrayList(delete);
        List updateList = Lists.newArrayList(update);

        compareMap = new ImmutableMap.Builder<PropertyChangeType, List<T>>().put(PropertyChangeType.ADDED, addList)
                .put(PropertyChangeType.DELETED, deleteList).put(PropertyChangeType.MODIFIED, updateList).build();

        diff();

        return (Map) compareMap;
    }

    public List<T> getAddList() {
        return getList(PropertyChangeType.ADDED);
    }

    public List<T> getUpdateList() {
        return getList(PropertyChangeType.MODIFIED);
    }

    public List<T> getDeleteList() {
        return getList(PropertyChangeType.DELETED);
    }

    private List<T> getList(PropertyChangeType propertyChangeType) {
        return Optional.ofNullable(compareMap.get(propertyChangeType)).orElse(Collections.emptyList());
    }

    private void setCompareCollectionSize(Integer sizeNew, Integer sizeOld) {
        this.newCollectionSize = sizeNew;
        this.oldCollectionSize = sizeOld;
    }

    /**
     * 比较容器元素是否发生变化
     * 
     * @return true- diff,false- nondiff
     */
    private Boolean diff() {
        if (!oldCollectionSize.equals(newCollectionSize)) {
            this.diff = true;
        } else if (CollectionUtils.isNotEmpty(getList(PropertyChangeType.ADDED))
                || CollectionUtils.isNotEmpty(getList(PropertyChangeType.DELETED))) {
            this.diff = true;
        } else if (getList(PropertyChangeType.MODIFIED).size() == newCollectionSize) {
            this.diff = false;
        }
        return diff;
    }

    public static void main(String[] args) {
        List<Integer> l1 = Lists.newArrayList(1, 2, 3);
        List<Integer> l3 = Lists.newArrayList(1, 2, 3);
        CollectionCompareLite<Integer, Integer, Integer> compareLite = new CollectionCompareLite(l1, l3);

        System.out.println(compareLite.getAddList());
        System.out.println(compareLite.getDeleteList());
        System.out.println(compareLite.getUpdateList());
        System.out.println(compareLite.diff());

    }