Stream API 对两个 List 进行去重操作

在 Java 8 及以上版本中，可以使用 Lambda 表达式和 Stream API 对两个 List 进行去重操作。以下是几种常见的去重场景及对应的 Lambda 表达式实现方式：

1. 合并两个 List 并去重

List<String> list1 = Arrays.asList("A", "B", "C");
List<String> list2 = Arrays.asList("B", "C", "D");

// 合并并去重（使用 Stream.concat + distinct）
List<String> distinctList = Stream.concat(list1.stream(), list2.stream())
                                  .distinct()
                                  .collect(Collectors.toList());

System.out.println(distinctList); // [A, B, C, D]

2. 取两个 List 的交集（保留重复元素）

List<String> list1 = Arrays.asList("A", "B", "B", "C");
List<String> list2 = Arrays.asList("B", "C", "C", "D");

// 取交集（保留重复元素）
List<String> intersection = list1.stream()
                                .filter(list2::contains)
                                .collect(Collectors.toList());

System.out.println(intersection); // [B, B, C]

3. 取两个 List 的交集（去重）

List<String> list1 = Arrays.asList("A", "B", "B", "C");
List<String> list2 = Arrays.asList("B", "C", "C", "D");

// 取交集（去重）
List<String> distinctIntersection = list1.stream()
                                        .filter(list2::contains)
                                        .distinct()
                                        .collect(Collectors.toList());

System.out.println(distinctIntersection); // [B, C]

4. 取两个 List 的差集（list1 有但 list2 没有）

List<String> list1 = Arrays.asList("A", "B", "C");
List<String> list2 = Arrays.asList("B", "C", "D");

// list1 有但 list2 没有的元素（去重）
List<String> difference = list1.stream()
                              .filter(e -> !list2.contains(e))
                              .collect(Collectors.toList());

System.out.println(difference); // [A]

5. 合并两个 List 并去重（自定义对象去重）

如果 List 里存放的是自定义对象（如 User），需要重写 equals() 和 hashCode() 方法，然后使用 distinct() 去重：

class User {
    private String name;
    private int age;

    // 构造方法、getter、setter 省略

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return age == user.age && Objects.equals(name, user.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

// 测试
List<User> list1 = Arrays.asList(new User("Alice", 20), new User("Bob", 25));
List<User> list2 = Arrays.asList(new User("Bob", 25), new User("Charlie", 30));

List<User> distinctUsers = Stream.concat(list1.stream(), list2.stream())
                                .distinct()
                                .collect(Collectors.toList());

distinctUsers.forEach(u -> System.out.println(u.getName())); // Alice, Bob, Charlie

6. 使用 Set 去重（更高效）

如果只是单纯去重，可以先把 List 转成 Set（自动去重），再转回 List：

List<String> list = Arrays.asList("A", "B", "B", "C");
List<String> distinctList = new ArrayList<>(new HashSet<>(list));

System.out.println(distinctList); // [A, B, C]（顺序可能变化）

7、总结

场景	方法
合并两个 List 并去重	Stream.concat(list1.stream(), list2.stream()).distinct()
取交集（保留重复）	list1.stream().filter(list2::contains).collect(Collectors.toList())
取交集（去重）	list1.stream().filter(list2::contains).distinct().collect(Collectors.toList())
取差集（list1 有但 list2 没有）	list1.stream().filter(e -> !list2.contains(e)).collect(Collectors.toList())
自定义对象去重	重写 equals() 和 hashCode()，再用 distinct()

选择合适的方式取决于你的具体需求（是否保留顺序、是否需要高性能等）。