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

今天在工作的时候遇到了一个问题,就是List的去重,不想用双重for,感觉太low,不想用for+Map,感觉应该有更好的方法,于是,google之。发现java8的stream流能完美解决这个问题。

参考文档:https://blog.csdn.net/jiaobuchong/article/details/54412094

                http://blog.zhouhaocheng.cn/posts/35

新建一个Person实体类

public class Person {
    private int id;

    private String name;

    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
}

然后用的是其中最简短,但也是最难理解的办法

import java.util.*;
import java.util.stream.Collectors;

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person(1, "11");
        Person p2 = new Person(1, "22");
        Person p3 = new Person(2, "11");
        List<Person> persons = Arrays.asList(p1,p2,p3);
        List<Person> unique = persons.stream().collect(
                Collectors.collectingAndThen(
                        Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Person::getName))), ArrayList::new)
        );
        unique.forEach(p -> System.out.println(p));
    }
}
前面的没什么好说的,主要是
List<Person> unique = persons.stream().collect(
                Collectors.collectingAndThen(
                        Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Person::getName))), ArrayList::new)
        );
        unique.forEach(p -> System.out.println(p));

persons这个list的streamAPI的聚合操作collect可以让我们只关注结果,而collect方法里的collectingAndThen又是属 于                java.util.stream.Collector,collectingAndThen操作的解释是:先执行前面的操作,然后执行第二部操作后输出结果,这里我们执行的第一步操作就是Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Person::getName))),第二步就是将他输出为一个新的ArrayList。

第一步操作里又是用到Collectors接口,这次用的是toCollection方法,就是将方法里的函数或者参数转化为一个collection集合,这里,我们是将Comparator.comparing(Person::getName)转化为一个collection,这个collection是一个TreeSet。也就是有序的。因为我们需要去掉重复的值,这个set可以做到,而我们又要保持转化出来的collection依旧有序,所以使用的是一个TreeSet。

Comparator.comparing(Person::getName)这里呢,又用到了java.util.Comparator接口,这个接口倒是挺常用的。使用的是他的comparing方法,也就是比较参数的值是否相同,里面用到的是java8的新特性lambda表达式, :: 其实和.没太大区别,举个例子,最常用的System.out.println() 可以表达为System.out::println,可以达到一样的效果

 




### 回答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()` 的参数修改为其他属性即可。
评论 5
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值