获取两个List集合之间的交集、并集、差集、补集

---

概述

使用 java 获取两个 List 集合之间的交集、并集、差集、补集

1. 在日常开发中：经常会遇到对2个集合的操作，例如：2个集合之间取相同的元素（交集），2个集合之间取不相同的元素（差集） 等等。。。
2. 本文总结一下java中获取两个List之间的交集、并集、差集、补集的几种实现方式。
3. 概念定义：
   交集： 取2个集合中，相同的部分 （list1 交集 list2，取 list1和list2 中相同的元素）
   并集： 将2个集合，合并为一个集合中
   差集： 取2个集合中，不相同的部分 （list1 差集 list2 ，取 list1中与list2 不相同的元素）
   补集： 取2个集合中，不相同的部分 ，组成新集合 （ list1 差集 list2 并 list2 差集 list1)

示例

定义两个集合

private List<Integer> list1 = Lists.newArrayList(1,2,3,4,5);
private List<Integer> list2 = Lists.newArrayList(4,5,6,7,8);

1、交集

@Test
public void intersection() {
    List<Integer> intersection = Lists.newArrayList();
    for (Integer e1 : list1) {
        for (Integer e2 : list2) {
            if (e1.equals(e2)) {
                intersection.add(e1);
            }
        }
    }
    System.out.println("intersection <手动遍历> 交集结果是： " + intersection);

    intersection = list1.stream()
            .filter(list2::contains)
            .collect(Collectors.toList());
    System.out.println("intersection <Stream流> 交集结果是： " + intersection);

    list1.retainAll(list2);
    System.out.println("intersection <retainAll> 方法 交集结果是： " + list1);

    Collection collection = CollectionUtils.intersection(list1, list2);
    System.out.println("intersection <CollectionUtils.intersection> 方法 交集结果是：" + collection);
}

交集 — 输出结果

2、并集

@Test
public void union() {
    list1.addAll(list2);
    System.out.println("union 并集 :" + list1);

    // 并集 去重
    HashSet<Integer> set = Sets.newHashSet();
    set.addAll(list1);
    set.addAll(list2);
    System.out.println("union 并集 去重 :" + set);

    Collection collection = CollectionUtils.union(list1, list2);
    System.out.println("union <CollectionUtils.union> 方法 并集结果是：" + collection);
}

并集 — 输出结果

3、差集

@Test
public void subtract() {
    list1.removeAll(list2);
    System.out.println("subtract 差集： " + list1);

    Collection collection = CollectionUtils.subtract(list1, list2);
    System.out.println("subtract <CollectionUtils.subtract> 方法 差集结果是：" + collection);
}

差集 — 输出结果

4、补集
使用循环对比

@Test
public void disjunctionTest1() {
    List<Integer> list1 = Lists.newArrayList(1,2,3,4,5);
    List<Integer> list2 = Lists.newArrayList(4,5,6,7,8);
    
    List<Integer> destList = Lists.newArrayList();
    boolean flag = false;
    for (Integer e1 : list1) {
        for (Integer e2 : list2) {
            if (e1.equals(e2)) {
                flag = true;
                break;
            }
        }
        if (!flag) {
            destList.add(e1);
        } else {
            flag = false;
        }
    }

    // list1 和 list2 换位置对比下
    flag = false;
    for (Integer e1 : list2) {
        for (Integer e2 : list1) {
            if (e1.equals(e2)) {
                flag = true;
                break;
            }
        }
        if (!flag) {
            destList.add(e1);
        } else {
            flag = false;
        }
    }
    System.out.println("disjunction 补集：" + destList);
}

使用Map集合

@Test
publicvoid disjunctionTest2() {
    List<Integer> destList = Lists.newArrayList();
    Map<Integer, Integer> map1 = list1.stream().collect(Collectors.toMap(k -> k, v -> v));
    Map<Integer, Integer> map2 = list2.stream().collect(Collectors.toMap(k -> k, v -> v));

    map1.forEach((k, v) -> {
        Integer val = map2.get(k);
        if (null == val) {
            destList.add(k);
        }
    });

    map2.entrySet().stream().forEach(e -> {
        Integer key = e.getKey();
        Integer val = map1.get(key);
        if (null == val) {
            destList.add(key);
        }
    });
    System.out.println("disjunction 补集：" + destList);
}

使用 CollectionUtils.disjunction

@Test
public void disjunctionTest3() {
    Collection disjunction = CollectionUtils.disjunction(list1, list2);
    System.out.println("disjunction 补集：" +disjunction);
}

使用 list1 和 list2相互差集，再并集

@Test
public void disjunctionTest4() {
    Collection s1 = CollectionUtils.subtract(list1, list2);
    Collection s2 = CollectionUtils.subtract(list2, list1);
    Collection union = CollectionUtils.union(s1, s2);
    System.out.println("disjunction 补集：" +union);
}

补集 — 输出结果

总结

1、本文记录了 Java中List集合的常见处理，可以手动写方法实现
2、上文依赖的 pom ：

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.8.1</version>
</dependency>
<dependency>
    <groupId>commons-collections</groupId>
	<artifactId>commons-collections</artifactId>
	<version>3.2</version>
</dependency>