CollectionUtils工具类的常用方法（集合得比较，交集、并集、补集）

**集合判断**： 
　　例1: 判断集合是否为空:
　　CollectionUtils.isEmpty(null): true
　　CollectionUtils.isEmpty(new ArrayList()): true　　
　　CollectionUtils.isEmpty({a,b}): false

　　例2: 判断集合是否不为空:
　　CollectionUtils.isNotEmpty(null): false
　　CollectionUtils.isNotEmpty(new ArrayList()): false
　　CollectionUtils.isNotEmpty({a,b}): true

 

CollectionUtils在真实项目中，是一个非常好用的工具类，使用非常频繁。它可以使代码更加简洁和安全。刚好在工作中利用这个工具类重构代码，顺便总结下分享分享:

**并集**
@Test
public void testUnion(){
    String[] arrayA = new String[] { "A", "B", "C", "D", "E", "F" };  
    String[] arrayB = new String[] { "B", "D", "F", "G", "H", "K" };
    List<String> listA = Arrays.asList(arrayA);
    List<String> listB = Arrays.asList(arrayB);
    //2个数组取并集 
    System.out.println(ArrayUtils.toString(CollectionUtils.union(listA, listB)));
    //[A, B, C, D, E, F, G, H, K]
}
**交集**
@Test
public void testIntersection(){
    String[] arrayA = new String[] { "A", "B", "C", "D", "E", "F" };  
    String[] arrayB = new String[] { "B", "D", "F", "G", "H", "K" };
    List<String> listA = Arrays.asList(arrayA);
    List<String> listB = Arrays.asList(arrayB);
    //2个数组取交集 
    System.out.println(ArrayUtils.toString(CollectionUtils.intersection(listA, listB)));
    //[B, D, F]

}
**交集的补集（析取）**
@Test
public void testDisjunction(){
    String[] arrayA = new String[] { "A", "B", "C", "D", "E", "F" };  
    String[] arrayB = new String[] { "B", "D", "F", "G", "H", "K" };
    List<String> listA = Arrays.asList(arrayA);
    List<String> listB = Arrays.asList(arrayB);
    //2个数组取交集 的补集
    System.out.println(ArrayUtils.toString(CollectionUtils.disjunction(listA, listB)));
    //[A, C, E, G, H, K]
}
**差集（扣除）**
@Test
public void testSubtract(){
    String[] arrayA = new String[] { "A", "B", "C", "D", "E", "F" };  
    String[] arrayB = new String[] { "B", "D", "F", "G", "H", "K" };
    List<String> listA = Arrays.asList(arrayA);
    List<String> listB = Arrays.asList(arrayB);
    //arrayA扣除arrayB
    System.out.println(ArrayUtils.toString(CollectionUtils.subtract(listA, listB)));
    //[A, C, E]

}

// 如果需要转成集合类型，可以直接将其转化为其他集合类型
Set<String> resultSet = new HashSet<>(CollectionUtils.subtract(listA, listB));  // 将结果转为 HashSet
List<String> resultList = new ArrayList<>(CollectionUtils.subtract(listA, listB));  // 将结果转为 ArrayList

//ArrayUtil.toArray()用的是：cn.hutool.core.util.ArrayUtil
List<String> subtractIdList = Arrays.asList(ArrayUtil.toArray(CollectionUtils.subtract(listA, listB), String.class));

**集合是否为空**
@Test
public void testIsEmpty(){

    class Person{}
    class Girl extends Person{}

    List<Integer> first = new ArrayList<>();
    List<Integer> second = null;
    List<Person> boy = new ArrayList<>();
    //每个男孩心里都装着一个女孩
    boy.add(new Girl());
    //判断集合是否为空
    System.out.println(CollectionUtils.isEmpty(first));   //true
    System.out.println(CollectionUtils.isEmpty(second));   //true
    System.out.println(CollectionUtils.isEmpty(boy));   //false

    //判断集合是否不为空
    System.out.println(CollectionUtils.isNotEmpty(first));   //false
    System.out.println(CollectionUtils.isNotEmpty(second));   //false
    System.out.println(CollectionUtils.isNotEmpty(boy));   //true
}
**集合是否相等**
@Test
public void testIsEqual(){

    class Person{}
    class Girl extends Person{
    }

    List<Integer> first = new ArrayList<>();
    List<Integer> second = new ArrayList<>();
    first.add(1);
    first.add(2);
    second.add(2);
    second.add(1);
    Girl goldGirl = new Girl();
    List<Person> boy1 = new ArrayList<>();
    //每个男孩心里都装着一个女孩
    boy1.add(new Girl());
    List<Person> boy2 = new ArrayList<>();
    //每个男孩心里都装着一个女孩
    boy2.add(new Girl());
    //比较两集合值
    System.out.println(CollectionUtils.isEqualCollection(first,second));   //true
    System.out.println(CollectionUtils.isEqualCollection(first,boy1));   //false
    System.out.println(CollectionUtils.isEqualCollection(boy1,boy2));   //false

    List<Person> boy3 = new ArrayList<>();
    //每个男孩心里都装着一个女孩
    boy3.add(goldGirl);
    List<Person> boy4 = new ArrayList<>();
    boy4.add(goldGirl);
    System.out.println(CollectionUtils.isEqualCollection(boy3,boy4));   //true
    }
不可修改的集合
我们对c进行操作，s也同样获得了和c相同的内容，这样就可以避免其他人员修改这个s对象。有时候需要对它进行保护，避免返回结果被人修改。




        ArrayList<Object> list1 = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list1.add(i);
        }
        ArrayList<Object> list2 = new ArrayList<>();
        for (int i = 6; i < 10; i++) {
            list2.add(i);
        }
        //addAll 和集合的并集运算相似
        list1.addAll(list2);
        System.out.println(list1);
        //结果:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 6, 7, 8, 9]
        ArrayList<Object> list3 = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list3.add(i);
        }
        ArrayList<Object> list4 = new ArrayList<>();
        for (int i = 6; i < 10; i++) {
            list4.add(i);
        }
        //removeAll 和集合的差集运算相似
        list3.removeAll(list4);
        System.out.println(list3);
        //结果:[0, 1, 2, 3, 4, 5]

        ArrayList<Object> list5 = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list5.add(i);
        }
        ArrayList<Object> list6 = new ArrayList<>();
        for (int i = 6; i < 10; i++) {
            list6.add(i);
        }
        //retainAll 和集合的交集运算相似
        list5.retainAll(list6);
        System.out.println(list5);
        //结果:[6, 7, 8, 9]