高级JAVA - 利用函数式接口实现通用的取并集/交集/差集进阶版

在前文(高级JAVA - 利用函数式接口实现通用的取并集/交集/差集)中我们实现了利用函数式接口获取交集/差集 , 但是只能全部生成 , 假如我们只需要一个交集的话 , 所有代码仍然会执行一次 . 比较浪费资源 , 故再改进一版

package com.xing.dto;

import com.xing.common.utils.XDataUtil;

import java.util.List;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * @title 两个集合的聚合数据 , 包含并集/交集/差集
 * @author Xingbz
 * @createDate 2019-7-23
 */
public class GatherData<T, R> {
    /** 新数据集合 */
    private List<T> newList;
    /** 旧数据集合(一般为数据库记录) */
    private List<T> oldList;
    /** 新数据标识值集合 */
    private List<R> newIdList;
    /** 旧数据标识值集合 */
    private List<R> oldIdList;
    /** 业务转换对象(处理两个集合中用来标识唯一的属性) */
    private Function<T, R> func;

    /** 并集 - 新集合加旧集合的数据(去重) */
    private List<T> unionList;

    /** 交集 - 新集合和旧集合都有的数据 */
    private List<T> intersectList;

    /** 主差集 - 新集合有 , 旧集合没有的数据 */
    private List<T> exceptMainList;

    /** 次差价 - 旧集合有 , 新集合没有的数据 */
    private List<T> exceptMinorList;

    /** 构造器私有 , 仅可通过对外的工厂方法访问 */
    private GatherData(List<T> newList, List<T> oldList, Function<T, R> func) {
        this.newList = newList;
        this.oldList = oldList;
        this.func = func;
    }

    private List<R> getNewIdList() {
        if (Objects.isNull(newIdList)) {
            newIdList = newList.stream().map(func).collect(Collectors.toList());
        }
        return newIdList;
    }

    private List<R> getOldIdList() {
        if (Objects.isNull(oldIdList)) {
            oldIdList = oldList.stream().map(func).collect(Collectors.toList());
        }
        return oldIdList;
    }

    /** @title 获取并集 */
    public List<T> getUnionList() {
        if (Objects.isNull(unionList)) {
            unionList = XDataUtil.addAllList(getIntersectList(), getExceptMainList(), getExceptMinorList());
        }
        return unionList;
    }

    /** @title 获取交集 */
    public List<T> getIntersectList() {
        if (Objects.isNull(intersectList)) {
            intersectList = oldList.stream().filter(t -> getNewIdList().contains(func.apply(t))).collect(Collectors.toList());
        }
        return intersectList;
    }

    /** @title 获取主差集 */
    public List<T> getExceptMainList() {
        if (Objects.isNull(exceptMainList)) {
            exceptMainList = newList.stream().filter(t -> !getOldIdList().contains(func.apply(t))).collect(Collectors.toList());
        }
        return exceptMainList;
    }

    /** @title 获取次差集 */
    public List<T> getExceptMinorList() {
        if (Objects.isNull(exceptMinorList)) {
            exceptMinorList = oldList.stream().filter(t -> !getNewIdList().contains(func.apply(t))).collect(Collectors.toList());
        }
        return exceptMinorList;
    }

    /** 遍历交集操作 */
    public void unionEach(Consumer<? super T> consumer) {
        getUnionList().forEach(consumer);
    }

    /** 遍历交集操作 */
    public void intersectEach(Consumer<? super T> consumer) {
        getIntersectList().forEach(consumer);
    }

    /** 遍历主差集操作 */
    public void exceptMainEach(Consumer<? super T> consumer) {
        getExceptMainList().forEach(consumer);
    }

    /** 遍历次差集操作 */
    public void exceptMinorEach(Consumer<? super T> consumer) {
        getExceptMinorList().forEach(consumer);
    }

    /** 对外方法 , 实例化数据 */
    public static <T, R> GatherData<T, R> instance(List<T> newList, List<T> oldList, Function<T, R> func) {
        return new GatherData<>(newList, oldList, func);
    }
}