Java List 集合取 交集、并集、差集、补集 Java集合取交集、Java集合并集

一、概述

        1、在日常开发中：

      经常会遇到对2个集合的操作，例如：2个集合之间取相同的元素（交集），2个集合之间取不相同的元素（差集） 等等。。。

        2、本文系统性的整理：

        Java中 集合 交集、并集、差集、补集的处理办法，并提供多种办法实现，由浅入深 --- 简化到最后一行代码实现。

        3、概念定义：

• 交集： 取2个集合中，相同的部分 （list1 交集 list2，取 list1和list2 中相同的元素）
• 并集： 将2个集合，合并为一个集合中
• 差集： 取2个集合中，不相同的部分 （list1 差集 list2 ，取 list1中与list2 不相同的元素）
• 补集： 取2个集合中，不相同的部分 ，组成新集合 （ list1 差集 list2 并 list2 差集 list1)

        （PS：此处应该有个图来，更好理解！）

二、代码实现理解

        1、假设有2个集合，list1 和 list2 ，元素分别如下：

ArrayList<Integer> list1 = Lists.newArrayList(1,2,3);
ArrayList<Integer> list2 = Lists.newArrayList(3,4,5);

        2、取交集 --- 手动遍历集合实现

/**@Description: 取交集
 * @version v1.0
 * @author wu
 * @date 2022/7/30 22:41
 */
@Test
public void intersectionTest1(){
    ArrayList<Object> destList = Lists.newArrayList();
    for (Integer e1 : list1) {
        for (Integer e2 : list2) {
            if(e1.equals(e2)){
                destList.add(e1);
            }
        }
    }
    System.out.println("intersectionTest1 交集结果是： " + destList);

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

        2.1、取交集 --- 使用 CollectionUtils 工具类

/**@Description: 取交集 ， 使用 CollectionUtils 工具类
 * @version v1.0
 * @author wu
 * @date 2022/7/30 22:55
 */
@Test
public void intersectionTest2(){
    Collection intersection = CollectionUtils.intersection(list1, list2);
    System.out.println("intersectionTest2 交集结果是： " + intersection);
}

        2.2、取交集 --- 通用方法 实现

                list1 交集 list2 ，不用生成新的list ，使用 迭代器 Iterator 删除 list1中和list2 不相同的元素。 （list集合元素删除见文章：https://thinkcode.blog.csdn.net/article/details/80295755）

                (2022年11月15日22:21:35 增加）

 /**
     * Description: 测试 通用List集合取值交集的方法
     * @return  void
     * @version v1.0
     * @author wu
     * @date 2022/11/15 22:15
     */
    @Test
    public void intersectionListTest() throws Exception {
        System.out.println("srcList : \n"+ JSON.toJSONString(list));
        System.out.println("subList : \n"+ JSON.toJSONString(subList));

        intersectionList(list,subList,(t1,t2)->{
           if(t1.equals(t2)){
               return 0;
           }
          return -1;
        });

    }

    /**
     * Description: 通用List集合取值交集的方法
     * @param srcList
     * @param subList
     * @param comparator
     * @return  void
     * @version v1.0
     * @author wu
     * @date 2022/11/15 22:05
     */
    public <E>void intersectionList(List<E> srcList , List<E> subList , Comparator<E> comparator){
        for (Iterator<E> it = srcList.iterator(); it.hasNext(); ) {
            final E next = it.next();
            boolean isMatch = false;
            for (E e : subList) {
                if(comparator.compare(next,e) == 0){
                    isMatch = true;
                    break;
                }
            }
            if(!isMatch){
                it.remove();
            }
        }
        System.out.println("srcList 交集后: \n"+ JSON.toJSONString(list));
        System.out.println("subList 交集后: \n"+ JSON.toJSONString(subList));
    }

       

        3、取并集 --- 使用Set集合实现

/**@Description: 取并集
 * @version v1.0
 * @author wu
 * @date 2022/7/30 23:00
 */
@Test
public void unionTest1(){
    list1.addAll(list2);
    System.out.println("unionTest1 并集 :" + list1);

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

        3.1、取并集 ， 使用 CollectionUtils 实现

/**@Description: 取并集 ， 使用 CollectionUtils 实现
 * @version v1.0
 * @author wu
 * @date 2022/7/30 23:02
 */
@Test
public void unionTest2(){
    Collection union = CollectionUtils.union(list1, list2);
    System.out.println("unionTest2 并集  :" + union);
}

        4、取差集 ， 使用 removeAll 方法实现

/**@Description: 取 差集 ， list1 - list2
 * @version v1.0
 * @author wu
 * @date 2022/7/30 23:37
 */
@Test
public void subtractTest1(){
    list1.removeAll(list2);
    System.out.println("subtractTest1 差集： " + list1);
}

        4.1、取差集，使用 CollectionUtils 工具类

/**@Description: 取 差集 ，使用 CollectionUtils 工具类
 * @version v1.0
 * @author wu
 * @date 2022/7/30 23:46
 */
@Test
public void subtractTest2(){
    Collection subtract = CollectionUtils.subtract(list1, list2);
    System.out.println("subtractTest2 差集： " + subtract);
}

        5、取补集，使用 list 循环对比

/**@Description: 取补集 --- 使用 list 循环对比
 * @version v1.0
 * @author wu
 * @date 2022/7/30 23:03
 */
@Test
public void disjunctionTest1(){
    ArrayList<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("disjunctionTest1 补集：" +destList);
}

        5.1、取补集 --- 使用Map对比

/**@Description: 取补集 --- 使用Map对比
 * @version v1.0
 * @author wu
 * @date 2022/7/30 23:18
 */
@Test
public void disjunctionTest2() {
    ArrayList<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("disjunctionTest2 补集：" +destList);
}

        5.2、取补集 --- 使用 CollectionUtils.disjunction 方法

/**@Description: 取补集 --- 使用 CollectionUtils.disjunction 方法
 * @version v1.0
 * @author wu
 * @date 2022/7/30 23:56
 */
@Test
public void disjunctionTest3() {
    Collection disjunction = CollectionUtils.disjunction(list1, list2);
    System.out.println("disjunctionTest3 补集：" +disjunction);
}

        5.3、取补集 --- 使用 list1 和 list2相互差集，再并集

/**@Description: 取补集 --- 使用 list1 和 list2相互差集，再并集
 * @version v1.0
 * @author wu
 * @date 2022/7/30 23:57
 */
@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("disjunctionTest4 补集 , 2个差集再并集：" +union);
}

        注：以上代码，输出结果略，请自行粘贴代码测试！

三、总结

        1、本文记录了 Java中List集合的常见处理，可以手动写方法实现，也可以偷懒，直接借用已经造好的轮子，一行代码实现。多多熟悉这些工具类常见的API使用，提高工作效率，为 ... 摸鱼 .... 争取更多的时间。

        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>

可能需要知道的：

Idea 设置方法注释模板 Idea 2021.2配置方法类注释模板_HaHa_Sir的博客-CSDN博客_idea设置方法注释模板

Eclipse配置代码注释模板 Eclipse代码注释模板 Eclipse设置方法注释模板_HaHa_Sir的博客-CSDN博客_eclipse代码注释模板