java（List或Array数组）求交集、并集、差集, 泛型工具类

业务需要求不同类型的交集、并集、差集为避免代码冗余编写工具类。

注：list 转数组需传入数组，如果将原数组传入将会改变原数组的值，同时泛型数组又不可以实例化，解决方案：Arrays.copyOf(n,list.size())  ，使用copyOf功能，开辟返回集合的等长新数组，避免修改原数组。

public static <T>T[] getIntersection(T[] n,T[] m){
   List<T> list= MathUtils.getIntersection(Arrays.asList(n),Arrays.asList(m));
   return list.toArray(Arrays.copyOf(n,list.size()));
}

如下为工具类详细代码！！！！

package com.lock.demo.common;

import java.util.*;

/**
 * @author niunafei
 * @function
 * @email niunafei0315@163.com
 * @date 2018/12/21  下午2:24
 */
public class MathUtils {

    /**
     * list 求差集
     * @param n
     * @param m
     * @param <T>
     * @return
     */
    public static <T>List 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 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 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);
    }

    /**
     * 数组求差集
     * @param n
     * @param m
     * @param <T>
     * @return
     */
    public static <T>T[] getDifferenceSet(T[] n,T[] m){
       List<T> list= MathUtils.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= MathUtils.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=MathUtils.getUnion(Arrays.asList(n),Arrays.asList(m));
        return list.toArray(Arrays.copyOf(n,list.size()));
    }

    public static void main(String[] args){
        List<Integer> list=new ArrayList<>(Arrays.asList(1,2,3,4));
        List<Integer> list1=new ArrayList<>(Arrays.asList(3,4,5,6));
        System.out.println("list 差集"+getDifferenceSet(list,list1));
        System.out.println("list 并集"+getUnion(list,list1));
        System.out.println("list 交集"+getIntersection(list,list1));
        Integer[] array=new Integer[]{1,2,3,4};
        Integer[] array1=new Integer[]{3,4,5,6};
        //差集[1, 2, 5, 6]
        System.out.println("array 差集"+Arrays.toString(getDifferenceSet(array,array1)));
        //并集[1, 2, 3, 4, 5, 6]
        System.out.println("array 并集"+Arrays.toString(getUnion(array,array1)));
        //交集[3, 4]
        System.out.println("array 交集"+Arrays.toString(getIntersection(array,array1)));

    }

}

　　

https://www.aliyun.com/acts/product-section-2019/new-users?userCode=q3tq2yrp