java8实现List中对象属性的去重

java8的stream流能完美解对象集合去重问题.
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class UserCar {
    private Integer id;
    private String carNo;

    public static void main(String[] args) {
        List<UserCar> cars = new ArrayList<>();
        cars.add(UserCar.builder().id(1).carNo("AA").build());
        cars.add(UserCar.builder().id(2).carNo("AA").build());
        cars.add(UserCar.builder().id(2).carNo("AA").build());
        cars.add(UserCar.builder().id(3).carNo("AB").build());

         List<UserCar> carList = removeDuplicates4(cars);
        System.out.println(JSONObject.toJSONString(carList));
    }
}    
  • 第一种: 不使用java8
    private static List<UserCar> removeDuplicates(List<UserCar> userCars) {
        Set<UserCar> personSet = new TreeSet<UserCar>(Comparator.comparing(UserCar::getCarNo));
        personSet.addAll(userCars);

        return new ArrayList<UserCar>(personSet);
    }		

这也是大多数人第一想到的,借助 TreeSet 去重,其中 TreeSet 的其中一个构造函数接收一个排序的算法,同时这也会用到 TreeSet 的去重策略上.


public TreeSet(Comparator<? super E> comparator) {
        this(new TreeMap<>(comparator));
    }

  • 第二种: 炫酷的java8写法
    private static List<UserCar> removeDuplicates2(List<UserCar> cars) {
        return cars.stream().collect(Collectors.collectingAndThen(
                Collectors.toCollection(() -> new TreeSet<UserCar>(Comparator.comparing(UserCar::getCarNo))), ArrayList::new)
        );
    }
  • 第三种: 基于java8 过滤器实现
          private static List<UserCar> removeDuplicates3(List<UserCar> cars) {
        // 用于临时存放id
        List<String> filterCars = new ArrayList<>();

        return cars.stream().filter(
                e -> {
                    boolean found = !filterCars.contains(e.getCarNo());
                    filterCars.add(e.getCarNo());
                    return found;
                }
        ).collect(Collectors.toList());
    }

  • 第四种: 基于hutool实现

    /**
     * 使用hutool工具类
     * @param cars
     * @return
     */
    private static List<UserCar> removeDuplicates5(List<UserCar> cars) {
        return CollUtil.distinct(cars, UserCar::getCarNo, true);
    }
  • 14
    点赞
  • 53
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
### 回答1: 在Java 8,我们可以使用Stream API和Lambda表达式来根据list对象属性去重。下面是具体步骤: 1. 通过Stream API将list对象转换成Stream流; 2. 使用distinct()方法根据对象属性去重,该方法使用对象的equals()方法判断是否相等; 3. 如果对象类没有重写equals()方法,则需要在该类重写该方法,以保证根据对象属性去重的正确性; 4. 最后,使用collect()方法将Stream流转换回list对象。 以下是示例代码: ``` // 定义Person类 public class Person { private String name; private int age; // 构造方法和getter/setter方法省略 @Override public boolean equals(Object obj) { // 重写equals()方法 if (obj == this) { return true; } if (!(obj instanceof Person)) { return false; } Person person = (Person) obj; return this.name.equals(person.getName()) && this.age == person.getAge(); } } // 定义list对象 List<Person> personList = Arrays.asList( new Person("Alice", 20), new Person("Bob", 25), new Person("Alice", 20), new Person("Charlie", 30) ); // 根据名称和年龄属性去重 List<Person> distinctPersonList = personList.stream().distinct().collect(Collectors.toList()); ``` 以上代码将根据Person对象的name和age属性去重,最终输出的distinctPersonList为: ``` [Person{name='Alice', age=20}, Person{name='Bob', age=25}, Person{name='Charlie', age=30}] ``` ### 回答2: 在Java 8,可以使用stream()和distinct()方法对List对象属性进行去重。 首先,我们需要创建一个包含对象List,例如: ``` List<Person> personList = new ArrayList<>(); personList.add(new Person("Alice", 20)); personList.add(new Person("Bob", 20)); personList.add(new Person("Alice", 25)); ``` 其,每个Person对象包含两个属性,分别为name和age。我们现在需要根据name属性去重。 我们可以使用以下代码实现: ``` List<Person> distinctList = personList.stream() .filter(distinctByKey(Person::getName)) .collect(Collectors.toList()); public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) { Map<Object, Boolean> seen = new ConcurrentHashMap<>(); return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null; } ``` 以上代码,我们首先对personList使用stream()方法,然后使用filter()方法筛选出根据Person对象的name属性去重后的数据。在filter()方法,使用distinctByKey()方法从而实现去重。该方法使用了Java 8的ConcurrentHashMap进行操作,首先根据keyExtractor将name属性作为key,将Boolean.TRUE作为value存入ConcurrentHashMap,如果putIfAbsent()方法返回null,表示当前元素还未放入ConcurrentHashMap,即为不重复元素,否则返回已存在的元素,即为重复元素。 最后,使用collect()方法将去重后的元素存入distinctList。我们可以通过打印distinctList的元素数量进行验证去重是否成功。 该方法可以灵活地根据各种属性进行去重,只需更改keyExtractor即可。 ### 回答3: Java 8 提供了非常便捷、高效的方式根据 list 对象属性去重,主要借助 lambda 表达式和 Stream API 实现。下面讲解具体实现步骤: 1. 定义一个类,作为 list 的元素,并在该类定义需要去重属性: ``` public class Person { private int id; private String name; //......getters and setters省略 } ``` 2. 创建一个 list,添加元素: ``` List<Person> list = new ArrayList<>(); list.add(new Person(1, "Tom")); list.add(new Person(2, "Jerry")); list.add(new Person(1, "Tom")); list.add(new Person(3, "Lucy")); ``` 此时,list 包含 4 个元素,其第 1 个和第 3 个元素 id 属性相同,需要去重。 3. 使用 Stream API 和 lambda 表达式去重: ``` List<Person> distinctList = list.stream() .collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Person::getId))), ArrayList::new)); ``` 解释一下上述代码的实现思路:首先用 `.stream()` 将 list 转换成 Stream,然后用 `Collectors.collectingAndThen()` 把 Collector 转换成了另一个 Collector,这里直接使用了 `Collectors.toCollection()` 把结果转成 TreeSet(TreeSet 是有序的 Set),并使用 Comparator.comparing 对元素进行比较,根据 id 属性进行去重。 最后,再把结果转换成 ArrayList 即可。 4. 打印去重后的结果: ``` for (Person person : distinctList) { System.out.println(person.getId() + " " + person.getName()); } ``` 此时输出结果如下: ``` 1 Tom 2 Jerry 3 Lucy ``` 由于已经按 id 属性去重,所以输出结果不再包含重复元素。 总结来说,Java 8 根据 list 对象属性去重比较简单,同样的方法也适用于其他属性去重,只需要将 `Comparator.comparing()` 的参数修改为其他属性即可。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值