#1 Java进阶系列--交集、并集、差集

一、交集、并集、差集和补集的概念

注意：在集合论和数学的其他分支中，存在补集的两种定义:相对补集和绝对补集。
1、相对补集
若A 和B 是集合，则A 在B 中的相对补集是这样一个集合:其元素属于B但不属于A，B - A = { x| x∈B且x∉A}。
2、绝对补集
若给定全集U，有A⊆U，则A在U中的相对补集称为A的绝对补集(或简称补集)，写作∁UA。

二、代码实现

package com.yzh.maven.test;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class CollectionTest {
    /**
        @functionname:unique
        @description:为List元素去重
        @author:yzh
        @param:list
        @date:2018-09-02
    */
    public <T> List<T> unique(List<T> list){
        List<T> newList = new ArrayList<T>();
        Set<T> set = new HashSet<T>();
        //元素去重
        for(T t:list){
            if(!set.contains(t)){
                set.add(t);
            }
        }
        //将set转化为list
        for(T t:set){
            //set元素是无序的
            if(!newList.contains(t)){
                newList.add(t);
            }
        }
        return newList;
    }

    /**
        @functionname:intersect
        @description:两个list的交集
        @author:yzh
        @param:list1
        @param:list2
        @date:2018-09-02
    */
    public <T> List<T> intersect(List<T> list1,List<T> list2){
        //为list1元素去重
        List<T> fromList1 =  unique(list1);
        //为list2元素去重
        List<T> fromList2 =  unique(list2);
        List<T> toList =  new ArrayList<T>();
        for(T t:fromList1){
            if(fromList2.contains(t)){
                toList.add(t);
            }
        }
        return toList;
    }

    /**
        @functionname:union
        @description:两个list的并集
        @author:yzh
        @param:list1
        @param:list2
        @date:2018-09-02
    */
    public <T> List<T> union(List<T> list1,List<T> list2){
        //为list1元素去重
        List<T> fromList1 =  unique(list1);
        //为list2元素去重
        List<T> fromList2 =  unique(list2);
        Set<T> set = new HashSet<T>();
        List<T> toList =  new ArrayList<T>();
        //将fromList1的元素加入set
        for(T t:fromList1){
            if(!set.contains(t)){
                set.add(t);
            }
        }
        //将fromList2的元素加入set
        for(T t:fromList2){
            if(!set.contains(t)){
                set.add(t);
            }
        }
        //将set转化为list
        for(T t:set){
            //set元素是无序的
            if(!toList.contains(t)){
                toList.add(t);
            }
        }
        return toList;
    }

    /**
        @functionname:minus
        @description:获取list2相对list1的差集
        @author:yzh
        @param:list1
        @param:list2
        @date:2018-09-02
    */
    public <T> List<T> minus(List<T> list1,List<T> list2){
        //为list1元素去重
        List<T> fromList1 = unique(list1);
        //为list2元素去重
        List<T> fromList2 = unique(list2);
        List<T> toList =  new ArrayList<T>();
        for(T t:fromList1){
            if(!toList.contains(t)){
                toList.add(t);
            }
        }
        for(T t:fromList2){
            if(toList.contains(t)){
                toList.remove(t);
            }
        }
        return toList;
    }

    public static void main(String[] args) {
        CollectionTest c = new CollectionTest();
        List<Integer> list = new ArrayList<Integer>();
        for(int i = 0;i<5;i++){
            list.add(i);
        }
        list.add(2);
        list.add(3);
        System.out.println("list: ");
        for(int i:list){
            System.out.print(i+" ");
        }
        System.out.println("\n去除重复元素的list2: ");
        List<Integer>list2 = c.unique(list);
        for(int i:list2){
            System.out.print(i+" ");
        }
        List<Integer> list3 = new ArrayList<Integer>();
        for(int i = 3;i<5;i++){
            list3.add(i);
        }
        list3.add(20);
        list3.add(30);
        System.out.println("\nlist1和list2的交集list3: ");
        for(int i:list3){
            System.out.print(i+" ");
        }
        System.out.println("\nlist4: ");
        List<Integer> list4 = c.intersect(list,list3);
        for(int i:list4){
            System.out.print(i+" ");
        }

        System.out.println("\nlist1和list2的并集list5: ");
        List<Integer> list5 = c.union(list,list3);
        for(int i:list5){
            System.out.print(i+" ");
        }

        System.out.println("\nlist2相对于list1的差集list6: ");
        List<Integer> list6 = c.minus(list,list3);
        for(int i:list6){
            System.out.print(i+" ");
        }

        System.out.println("\nlist1相对于list2的差集list7: ");
        List<Integer> list7 = c.minus(list3,list);
        for(int i:list7){
            System.out.print(i+" ");
        }

    }
}
/**output:
list: 
0 1 2 3 4 2 3 
去除重复元素的list2: 
0 1 2 3 4 
list1和list2的交集list3: 
3 4 20 30 
list4: 
3 4 
list1和list2的并集list5: 
0 1 2 3 4 20 30 
list2相对于list1的差集list6: 
0 1 2 
list1相对于list2的差集list7: 
20 30 
**/