Java获取两个集合List的交集、补集、并集(相加)和差集(相减)的几种方式_Java

1 明确概念

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

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

1.1 并集

对于两个给定集合a、b，由两个集合所有元素构成的集合，叫做a和b的并集。

记作：aub 读作“a并b”

例：{3,5}u{2,3,4,6}= {2,3,4,5,6}

1.2 交集

对于两个给定集合a、b，由属于a又属于b的所有元素构成的集合，叫做a和b的交集。

记作： a∩b 读作“a交b”

例：a={1,2,3,4,5}，b={3,4,5,6,8}，a∩b={3,4,5}

1.3 补集

一般地，设s是一个集合，a是s的一个子集，由s中所有不属于a的元素组成的集合，叫做子集a在s中的绝对补集。

记作：∁ua，包括三层含义：

1）a是u的一个子集，即a⊊u;

2）∁ua表示一个集合，且∁ua⊊u;

3）∁ua是由u中所有不属于a的元素组成的集合，∁ua与a没有公共元素，u中的元素分布在这两个集合中。

2 使用apache工具包

2.1 导入依赖

<!-- apache 集合工具类 -->

<dependency>

    <groupid>org.apache.commons</groupid>

    <artifactid>commons-collections4</artifactid>

    <version>4.1</version>

</dependency>

2.2 代码如下：

public static final list<string> list1 = arrays.aslist("a", "b", "c", "d", "e", "f", null);

public static final list<string> list2 = arrays.aslist("1", "2", "3", "d", "e", "f", null);

/**

 * apache测试方法

 */

@test

public void apachetest() {

    system.out.println("交集：" + collectionutils.intersection(list1, list2)); // 交集

    system.out.println("补集：" + collectionutils.disjunction(list1, list2)); // 补集

    system.out.println("并集：" + collectionutils.union(list1, list2)); // 并集

    system.out.println("list1的差集：" + collectionutils.subtract(list1, list2)); // list1的差集

    system.out.println("list2的差集：" + collectionutils.subtract(list2, list1)); // list2的差集

}

输出:

3 使用hutool工具包

3.1 导入依赖

<!-- hutool工具类 -->

<dependency>

    <groupid>cn.hutool</groupid>

    <artifactid>hutool-all</artifactid>

    <version>5.8.12</version>

</dependency>

3.2 代码如下：

public static final list<string> list1 = arrays.aslist("a", "b", "c", "d", "e", "f", null);

public static final list<string> list2 = arrays.aslist("1", "2", "3", "d", "e", "f", null);

/**

 * hutool工具类

 */

@test

public void hutooltest() {

    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.subtract(list1,list2));

    system.out.println("list2的差集"+collectionutil.subtract(list2,list1));

    system.out.println("list1的差集：" + collectionutil.subtracttolist(list1, list2));

    system.out.println("list2的差集：" + collectionutil.subtracttolist(list2, list1));

}

输出:

3.3 注意

subtract()和subtracttolist()作用一样，不过处理方式不同，使用subtract()时，参数不能是arrays.aslist()的结果，否则会报异常，因为arrays.aslist()返回的对象是arrays.arraylist，在方法实现里面调用的是abstractlist抽象类里面的removeall()方法，该方法代码如下：

public abstract class abstractlist<e> extends abstractcollection<e> implements list<e> {

    // ....

    public e remove(int index) {

        throw new unsupportedoperationexception();

    }

    // ....

}

4 使用stream方式

4.1 代码如下:

public static final list<string> list1 = arrays.aslist("a", "b", "c", "d", "e", "f", null);

public static final list<string> list2 = arrays.aslist("1", "2", "3", "d", "e", "f", null);

/**

 * stream方式

 */

@test

public void streamtest() {

    list<object> intersection = list1.stream().filter(list2::contains).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);

}

输出:

5 使用collection接口中的方法

5.1 代码如下:

public static string[] attr1 = new string[]{"a", "b", "c", "d", "e", "f", null};

public static string[] attr2 = new string[]{"1", "2", "3", "d", "e", "f", null};

/**

 * 使用collection接口中的方法

 */

@test

public void collectiontest() {

    list<string> list1 = new arraylist<>(arrays.aslist(attr1));

    list<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));

    set<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);

}

输出: