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

概念定义：

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

首先知道几个单词的意思：

交集 = intersection
并集 = union
补集 = complement
析取 = disjunction
减去 = subtract

推荐使用 stream 方式

一、apache工具包

导入依赖

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.5.0-M2</version>
        </dependency>

代码:

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.ListUtils;

import java.util.Arrays;
import java.util.List;


public class ApacheList {

    private static String[] attr1 = new String[]{"A", "B", "C", "D", "E", "F", null};
    private static String[] attr2 = new String[]{"1", "2", "3", "D", "E", "F", null};
    private static List<String> list1 = Arrays.asList(attr1);
    private static List<String> list2 = Arrays.asList(attr2);

    public static void main(String[] args) {
        // 交集
        System.out.println("交集：" + ListUtils.intersection(list1, list2));
        // 补集
        System.out.println("补集：" + CollectionUtils.disjunction(list1, list2));
        // 并集
        System.out.println("并集：" + ListUtils.union(list1, list2));
        // list1的差集
        System.out.println("list1的差集：" + ListUtils.subtract(list1, list2));
        // list2的差集
        System.out.println("list2的差集：" + ListUtils.subtract(list2, list1));

    }

}

输出结果如下：

交集：[D, E, F, null]
补集：[A, 1, B, 2, C, 3]
并集：[A, B, C, D, E, F, null, 1, 2, 3, D, E, F, null]
list1的差集：[A, B, C]
list2的差集：[1, 2, 3]

二、hutool工具包 

导入依赖 

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-core</artifactId>
            <version>5.8.16</version>
        </dependency>

 代码:

import cn.hutool.core.collection.CollectionUtil;

import java.util.ArrayList;
import java.util.Arrays;

public class HutoolList {

    private static String[] attr1 = new String[]{"A", "B", "C", "D", "E", "F", null};
    private static String[] attr2 = new String[]{"1", "2", "3", "D", "E", "F", null};

    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>(Arrays.asList(attr1));
        ArrayList<String> list2 = new ArrayList<>(Arrays.asList(attr2));

        // 交集
        System.out.println("交集：" + CollectionUtil.intersection(list1, list2));
        // 补集
        System.out.println("补集：" + CollectionUtil.disjunction(list1, list2));
        //并集
        System.out.println("并集：" + CollectionUtil.union(list1, list2));
        // 差集
        System.out.println("list1的差集：" + CollectionUtil.subtractToList(list1, list2));
        System.out.println("list2的差集：" + CollectionUtil.subtractToList(list2, list1));
    }

}

输出结果如下:

交集：[null, D, E, F]
补集：[1, A, 2, B, 3, C]
并集：[null, 1, A, 2, B, 3, C, D, E, F]
list1的差集：[A, B, C]
list2的差集：[1, 2, 3]

三、stream方式 

代码：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class TestStream {
    private static String[] attr1 = new String[]{"A", "B", "C", "D", "E", "F", null};
    private static String[] attr2 = new String[]{"1", "2", "3", "D", "E", "F", null};
    static List<String> list1 = Arrays.asList(attr1);
    static List<String> list2 = Arrays.asList(attr2);

    public static void main(String[] args) {
        List<Object> intersection = list1.stream().filter(item -> list2.contains(item)).collect(Collectors.toList());
        System.out.println("交集：" + intersection);

        List<String> subtract1 = list1.stream().filter(s -> !list2.contains(s)).collect(Collectors.toList());
        System.out.println("集合list1的差集：" + subtract1);
        List<String> subtract2 = list2.stream().filter(s -> !list1.contains(s)).collect(Collectors.toList());
        System.out.println("集合list2的差集：" + subtract2);

        List<String> union1 = list1.parallelStream().collect(Collectors.toList());
        List<String> union2 = list2.parallelStream().collect(Collectors.toList());
        union1.addAll(union2);
        List<String> union3 = union1.stream().distinct().collect(Collectors.toList());
        System.out.println("并集：" + union3);
    }

}

结果：

交集：[D, E, F, null]
集合list1的差集：[A, B, C]
集合list2的差集：[1, 2, 3]
并集：[A, B, C, D, E, F, null, 1, 2, 3]

四、原生方法 

 代码：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;

public class TestCollection {
    private static String[] attr1 = new String[]{"A", "B", "C", "D", "E", "F", null};
    private static String[] attr2 = new String[]{"1", "2", "3", "D", "E", "F", null};

    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>(Arrays.asList(attr1));
        ArrayList<String> list2 = new ArrayList<>(Arrays.asList(attr2));
        list1.retainAll(list2);
        System.out.println("交集：" + list1);

        ArrayList<String> list3 = new ArrayList<>(Arrays.asList(attr1));
        ArrayList<String> list4 = new ArrayList<>(Arrays.asList(attr2));
        HashSet<Object> set = new HashSet<>();

        set.addAll(list3);
        set.addAll(list4);
        System.out.println("并集：" + set);

        ArrayList<String> list5 = new ArrayList<>(Arrays.asList(attr1));
        ArrayList<String> list6 = new ArrayList<>(Arrays.asList(attr2));
        list5.removeAll(list6);
        System.out.println("集合A的差集：" + list5);
        ArrayList<String> list7 = new ArrayList<>(Arrays.asList(attr1));
        ArrayList<String> list8 = new ArrayList<>(Arrays.asList(attr2));
        list8.removeAll(list7);
        System.out.println("集合B的差集：" + list8);
    }

}

结果：

交集：[D, E, F, null]
并集：[null, A, 1, B, 2, C, 3, D, E, F]
集合A的差集：[A, B, C]
集合B的差集：[1, 2, 3]