業務需要求不同型別的交集、並集、差集為避免程式碼冗餘編寫工具類。

注：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 [email protected]
 * @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)));


    }

}