集合常用算法工具

@Slf4j
public class MathUtil {
    /**
     * list 求差集
     *
     * @param n
     * @param m
     * @param <T>
     * @return
     */
    public static <T> List<T> getDifferenceSet(List<T> n, List<T> m) {
        //转化最长列表
        Set<T> set = new HashSet<>(n.size() > m.size() ? n : m);
        //循环最短列表
        for (T t : n.size() > m.size() ? m : n) {
            if (set.contains(t)) {
                set.remove(t);
            } else {
                set.add(t);
            }
        }
        return new ArrayList<>(set);
    }

    /**
     * list 求交集
     *
     * @param n
     * @param m
     * @param <T>
     * @return
     */
    public static <T> List<T> getIntersection(List<T> n, List<T> m) {
        Set<T> setN = new HashSet<>(n);
        Set<T> setM = new HashSet<>(m);
        setN.retainAll(setM);
        return new ArrayList<>(setN);
    }

    /**
     * list 集合并集
     *
     * @param n
     * @param m
     * @param <T>
     * @return
     */
    public static <T> List<T> getUnion(List<T> n, List<T> m) {
        Set<T> setN = new HashSet<>(n);
        Set<T> setM = new HashSet<>(m);
        setN.addAll(setM);
        return new ArrayList<>(setN);
    }


    /**
     * list 集合减法
     *
     * @param minute
     * @param minus
     * @param <T>
     * @return
     */
    public static <T> List<T> getSubtraction(List<T> minute, List<T> minus) {
        List<T> intersection = MathUtil.getIntersection(minute, minus);
        return MathUtil.getDifferenceSet(minute, intersection);
    }

    /**
     * 数组求差集
     *
     * @param n
     * @param m
     * @param <T>
     * @return
     */
    public static <T> T[] getDifferenceSet(T[] n, T[] m) {
        List<T> list = MathUtil.getDifferenceSet(Arrays.asList(n), Arrays.asList(m));
        return list.toArray(Arrays.copyOf(n, list.size()));
    }

    /**
     * 数组求交集
     *
     * @param n
     * @param m
     * @param <T>
     * @return
     */
    public static <T> T[] getIntersection(T[] n, T[] m) {
        List<T> list = MathUtil.getIntersection(Arrays.asList(n), Arrays.asList(m));
        return list.toArray(Arrays.copyOf(n, list.size()));
    }

    /**
     * 数组并集
     *
     * @param n
     * @param m
     * @param <T>
     * @return
     */
    public static <T> T[] getUnion(T[] n, T[] m) {
        List<T> list = MathUtil.getUnion(Arrays.asList(n), Arrays.asList(m));
        return list.toArray(Arrays.copyOf(n, list.size()));
    }

    /**
     * 数组减法
     *
     * @param minute
     * @param minus
     * @param <T>
     * @return
     */
    public static <T> T[] getSubtraction(T[] minute, T[] minus) {
        T[] intersection = MathUtil.getIntersection(minute, minus);
        return MathUtil.getDifferenceSet(minute, intersection);
    }

    public static void main(String[] args) {
        List<Integer> listA = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
        List<Integer> listB = new ArrayList<>(Arrays.asList(3, 4, 5, 6));
        log.info("初始化：listA=" + listA + ", listB=" + listB);
        log.info("list 差集" + getDifferenceSet(listA, listB));
        log.info("list 并集" + getUnion(listA, listB));
        log.info("list 交集" + getIntersection(listA, listB));
        log.info("list 减集" + getSubtraction(listA, listB));
        log.info("操作后：listA=" + listA + ", listB=" + listB);
        Integer[] arrayA = new Integer[]{1, 2, 3, 4};
        Integer[] arrayB = new Integer[]{3, 4, 5, 6};
        log.info("初始化：arrayA=" + Arrays.toString(arrayA) + ", arrayB=" + Arrays.toString(arrayB));
        //差集[1, 2, 5, 6]
        log.info("array 差集" + Arrays.toString(getDifferenceSet(arrayA, arrayB)));
        //并集[1, 2, 3, 4, 5, 6]
        log.info("array 并集" + Arrays.toString(getUnion(arrayA, arrayB)));
        //交集[3, 4]
        log.info("array 交集" + Arrays.toString(getIntersection(arrayA, arrayB)));
        //交集[3, 4]
        log.info("array 减集" + Arrays.toString(getSubtraction(arrayA, arrayB)));
        log.info("操作后：arrayA=" + Arrays.toString(arrayA) + ", arrayB=" + Arrays.toString(arrayB));
    }