jdk8 List取交集、并集（不去重）、并集（去重）、补集、差集

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class ListUtils {

    /**
     * 获取两个列表的交集。
     *
     * @param list1 第一个列表
     * @param list2 第二个列表
     * @param <T>   列表元素类型
     * @return 交集列表
     */
    public static <T> List<T> getIntersection(List<T> list1, List<T> list2) {
        return list1.stream()
                .filter(list2::contains)
                .collect(Collectors.toList());
    }

    /**
     * 获取两个列表的并集（不去重）。
     *
     * @param list1 第一个列表
     * @param list2 第二个列表
     * @param <T>   列表元素类型
     * @return 并集列表（包含所有元素，包括重复的）
     */
    public static <T> List<T> getUnionAll(List<T> list1, List<T> list2) {
        return Stream.concat(list1.stream(), list2.stream())
                .collect(Collectors.toList());
    }

    /**
     * 获取两个列表的并集（去重）。
     *
     * @param list1 第一个列表
     * @param list2 第二个列表
     * @param <T>   列表元素类型
     * @return 并集列表（去除重复元素）
     */
    public static <T> List<T> getUnionDistinct(List<T> list1, List<T> list2) {
        return Stream.concat(list1.stream(), list2.stream())
                .distinct()
                .collect(Collectors.toList());
    }

    /**
     * 获取两个列表的补集。
     * 补集包含只存在于一个列表中而不在另一个列表中的元素。
     *
     * @param list1 第一个列表
     * @param list2 第二个列表
     * @param <T>   列表元素类型
     * @return 补集列表
     */
    public static <T> List<T> getComplement(List<T> list1, List<T> list2) {
        List<T> complement = new ArrayList<>();
        complement.addAll(list1.stream()
                .filter(e -> !list2.contains(e))
                .collect(Collectors.toList()));
        complement.addAll(list2.stream()
                .filter(e -> !list1.contains(e))
                .collect(Collectors.toList()));
        return complement;
    }

    /**
     * 获取两个列表的差集。
     * 差集包含存在于第一个列表中而不在第二个列表中的元素。
     *
     * @param list1 第一个列表
     * @param list2 第二个列表
     * @param <T>   列表元素类型
     * @return 差集列表
     */
    public static <T> List<T> getDifference(List<T> list1, List<T> list2) {
        return list1.stream()
                .filter(e -> !list2.contains(e))
                .collect(Collectors.toList());
    }
}

方法调用：

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

List<Integer> intersection = ListUtils.getIntersection(list1, list2);
System.out.println("Intersection: " + intersection);

List<Integer> unionAll = ListUtils.getUnionAll(list1, list2);
System.out.println("Union (All): " + unionAll);

List<Integer> unionDistinct = ListUtils.getUnionDistinct(list1, list2);
System.out.println("Union (Distinct): " + unionDistinct);

List<Integer> complement = ListUtils.getComplement(list1, list2);
System.out.println("Complement: " + complement);

List<Integer> difference = ListUtils.getDifference(list1, list2);
System.out.println("Difference: " + difference);