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()

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

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值