<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-collections4 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.4</version>
        </dependency>

 /** 1、除非元素為null，否則向集合添加元素 */ 
CollectionUtils.addIgnoreNull(personList,null); 
/** 2、將兩個(gè)已排序的集合a和b合并為一個(gè)已排序的列表，以便保留元素的自然順序 */ 
CollectionUtils.collate(Iterable<? extends O> a, Iterable<? extends O> b) 
/** 3、將兩個(gè)已排序的集合a和b合并到一個(gè)已排序的列表中，以便保留根據(jù)Comparator c的元素順序。 */ 
CollectionUtils.collate(Iterable<? extends O> a, Iterable<? extends O> b, Comparator<? super O> c) 
/** 4、返回該個(gè)集合中是否含有至少有一個(gè)元素 */ 
CollectionUtils.containsAny(Collection<?> coll1, T... coll2) 
/** 5、如果參數(shù)是null，則返回不可變的空集合，否則返回參數(shù)本身。（很實(shí)用 ,最終返回List EMPTY_LIST = new EmptyList<>()） */ 
CollectionUtils.emptyIfNull(Collection<T> collection) 
/** 6、空安全檢查指定的集合是否為空 */ 
CollectionUtils.isEmpty(Collection <?> coll) 
/** 7、 空安全檢查指定的集合是否為空。 */ 
CollectionUtils.isNotEmpty(Collection <?> coll) 
/** 8、反轉(zhuǎn)給定數(shù)組的順序。 */ 
CollectionUtils.reverseArray(Object[] array); 
/** 9、差集 */ 
CollectionUtils.subtract(Iterable<? extends O> a, Iterable<? extends O> b) 
/** 10、并集 */
 CollectionUtils.union(Iterable<? extends O> a, Iterable<? extends O> b) 
/** 11、交集 */ 
CollectionUtils.intersection(Collection a, Collection b) 
/** 12、 交集的補(bǔ)集（析?。?*/
 CollectionUtils.disjunction(Collection  a, Collection b)

 public static void main(String[] args) {
        String[] arrayA = new String[]{"1","2","3","4"};
        String[] arrayB = new String[]{"3","4","5","6"};
        List<String> listA = Arrays.asList(arrayA);
        List<String> listB = Arrays.asList(arrayB); //1、并集 union
       System.out.println(CollectionUtils.union(listA,listB)); //輸出：[1, 2, 3, 4, 5, 6] //2、交集intersection
       System.out.println(CollectionUtils.intersection(listA,listB)); //輸出：[3, 4] //3、交集的補(bǔ)集(析取)disjunction
       System.out.println(CollectionUtils.disjunction(listA,listB)); //輸出：[1, 2, 5, 6] //4、差集(扣除)
       System.out.println(CollectionUtils.subtract(listA,listB)); //[1, 2]
}

 public static void main(String[] args) {
        String[] arrayA = new String[]{"1","2","3","4"};
        String[] arrayB = new String[]{"3","4","5","6"};
        List<String> listA = Arrays.asList(arrayA);
        List<String> listB = Arrays.asList(arrayB); //1交集
        List<String> jiaoJiList = new ArrayList<>(listA);
        jiaoJiList.retainAll(listB);
        System.out.println(jiaoJiList); //輸出：[3, 4] //2差集
        List<String> chaJiList = new ArrayList<>(listA);
        chaJiList.removeAll(listB);
        System.out.println(chaJiList); //輸出：[1, 2] //3并集（先做差集在做添加所有）
        List<String> bingList = new ArrayList<>(listA);
        bingList.removeAll(listB);//[1,2]
        bingList.addAll(listB);//[3,4,5,6]
        System.out.println(bingList); //輸出：[1, 2, 3, 4, 5, 6]
}

public static void main(String[] args) {
        String[] arrayA=new String[]{"1","2","3","4"};
        String[] arrayB=new String[]{"3","4","5","6"};
        List<String> listA = Arrays.asList(arrayA);
        List<String> listB = Arrays.asList(arrayB); //交集
        List<String> intersection = listA.stream().filter(item -> listB.contains(item)).collect(Collectors.toList());
        System.out.println(intersection); //輸出：[3, 4] //并集（新建集合：1、是因?yàn)椴挥绊懺技希?、    Arrays.asList不能add和remove操作）
        List<String> listAll = listA.parallelStream().collect(Collectors.toList());
        List<String> listAll2 = listB.parallelStream().collect(Collectors.toList());
        listAll.addAll(listAll2);
        System.out.println(listAll); //輸出：[1, 2, 3, 4, 3, 4, 5, 6] //差集
        List<String> reduceList = listA.stream().filter(item -> !listB.contains(item)).collect(Collectors.toList());
        System.out.println(reduceList); //輸出：[1, 2] //去重并集
        ArrayList<String> list = new ArrayList<>(listA);
        list.addAll(listB);
        List<String> listAllDistinct = list.stream().distinct().collect(Collectors.toList());
        System.out.println(listAllDistinct); //輸出：[1, 2, 3, 4, 5, 6]
}

public static void main(String[] args) {
        List<Person> personList = Lists.newArrayList();
        Person person1 = new Person("小小", 15);
        Person person2 = new Person("中中", 16);
        personList.add(person1);
        personList.add(person2);
        List<Person> person1List = Lists.newArrayList();
        Person person3 = new Person("中中", 16);
        Person person4 = new Person("大大", 17);
        person1List.add(person3);
        person1List.add(person4); 
        /** 1、差集 */ 
        System.out.println(CollectionUtils.subtract(personList,person1List)); //輸出：[Person{name='小小', age=15}]
        /** 2、交集 */ 
        System.out.println(CollectionUtils.intersection(personList,person1List)); //輸出：[Person{name='中中', age=16}]
         /** 3、并集 */ 
        System.out.println(CollectionUtils.union(personList,person1List)); //輸出:[Person{name='小小', age=15},                 Person{name='大大', age=17}, Person{name='中中', age=16}]
         /** 4、交集的補(bǔ)集（析?。?*/ 
        System.out.println(CollectionUtils.disjunction(personList,person1List)); //輸出:[Person{name='小小', age=15}, Person{name='大大', age=17}]
}

public native int hashCode(); 
public boolean equals(Object obj){ 
    return (this == obj);  
}

public class People { 
    private String name; 
    private Integer age; 
    public People(String name, Integer age) { 
        this.name = name;
        this.age = age;
    } 
   /** 重寫equals方法
     * @param o
     * @return
     */ 
@Override 
public boolean equals(Object o) {
    if (this == o) return true; 
    if (o == null || getClass() != o.getClass()) return false;
    People people = (People) o; 
    return Objects.equals(name, people.name) && Objects.equals(age, people.age);
} 
/** * 重寫toString方法
     * @return
     */ 
@Override 
public String toString() { 
  return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public static void main(String[] args) {
        HashSet<People> hashSet = Sets.newHashSet();
        People people1 = new People("小小",3);
        People people2 = new People("中中",4);
        People people3 = new People("中中",4);
        People people4 = new People("大大",5);
        hashSet.add(people1);
        hashSet.add(people2);
        hashSet.add(people3);
        hashSet.add(people4);
        System.out.println(hashSet); 
      //輸出:[People{name='大大', age=5}, People{name='中中', age=4}, People{name='小小', age=3}, People{name='中中', age=4}]
}