JAVA实体类集合该如何去重？

已于 2023-12-14 15:08:11 修改
阅读量1.4k 收藏 25
点赞数 29
分类专栏： JavaSE 文章标签： java
于 2023-12-13 20:20:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Qizhi_Hu/article/details/134974996
版权

JAVA实体类集合该如何去重？

最近在工作中经常遇到需要去重的需求，所以特意系统的来梳理一下

有目录，不迷路

单元素去重

方法一：利用Set去重

 public static void main(String[] args) {

        // 生成含重复元素的集合并打印
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(2);
        list.add(3);
        System.out.println("去重前：" + list);


        // 利用HashSet去重后并打印
        HashSet<Integer> hashSet = new HashSet<>(list);
        list.clear();
        list.addAll(hashSet);
        System.out.println("去重后：" + list);
    }

执行：

在这里插入图片描述

方法二：利用java 8的stream写法，方便优雅快捷高效

 public static void main(String[] args) {

        // 生成含重复元素的集合并打印
        List<Integer> list = new ArrayList<>();
        list.add(2);
        list.add(3);
        list.add(3);
        list.add(4);
        System.out.println("去重前：" + list);


        // 利用java 8的stream写法
        list = list.stream().distinct().collect(Collectors.toList());
        System.out.println("去重后：" + list);
    }

执行：

在这里插入图片描述

实体类对象去重

先新建实体类：

/**
 * @Author: guqueyue
 * @Description: 学生类
 * @Date: 2023/12/12
 **/
public class Student {

    /** 姓名 */
    private String name;

    /** 年龄 */
    private Integer age;
    
    public Student() {
    }

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

单属性去重

方法一：利用map去重
public static void main(String[] args) {

        // 生成学生集合
        List<Student> studentList = new ArrayList<>();
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("张三", 19));
        studentList.add(new Student("张三", 22));
        studentList.add(new Student("李四", 18));
        System.out.println("去重前: " + studentList);

        // 利用map根据姓名去重
        Map<String, Student> map = new HashMap<>();
        for (Student student : studentList) {
            map.put(student.getName(), student);
        }
        studentList = new ArrayList<>(map.values());
        System.out.println("去重后: " + studentList);
    }

执行得：

在这里插入图片描述

方法二：利用map去重，java 8语法

比方法一代码看似简洁了，但实际上好似更加复杂了

 public static void main(String[] args) {

        // 生成学生集合
        List<Student> studentList = new ArrayList<>();
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("张三", 19));
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("李四", 18));
        System.out.println("去重前: " + studentList);

        // 利用map根据姓名去重，java 8语法
        studentList = studentList.stream()
                                 .collect(Collectors.toMap(student -> student.getName(), Function.identity(), (o, n) -> n))
                                 .values()
                                 .stream().collect(Collectors.toList());
        System.out.println("去重后: " + studentList);
    }

执行：

在这里插入图片描述

方法三：利用Set去重
public static void main(String[] args) {

        // 生成学生集合
        List<Student> studentList = new ArrayList<>();
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("张三", 19));
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("李四", 18));
        System.out.println("去重前: " + studentList);

        // 利用Set去重
//        Set<Student> set = new TreeSet<>(((o1, o2) -> o1.getName().compareTo(o2.getName())));
        Set<Student> set = new TreeSet<>((Comparator.comparing(Student::getName)));
        set.addAll(studentList);
        studentList.clear();
        studentList = new ArrayList<>(set);
        System.out.println("去重后: " + studentList);
    }

执行：

在这里插入图片描述

方法四： 利用Set去重，java 8写法
public static void main(String[] args) {

        // 生成学生集合
        List<Student> studentList = new ArrayList<>();
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("张三", 19));
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("李四", 18));
        System.out.println("去重前: " + studentList);

        // 利用Set去重，java 8写法
        studentList = studentList.stream().collect(
                                            Collectors.collectingAndThen(
                                                    Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Student::getName))),
                                                    ArrayList::new
                                            )
                                    );
        System.out.println("去重后: " + studentList);
    }

执行：

在这里插入图片描述

方法五：定义过滤器
public static void main(String[] args) {

        // 生成学生集合
        List<Student> studentList = new ArrayList<>();
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("张三", 19));
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("李四", 18));
        System.out.println("去重前: " + studentList);

        // 定义过滤器
        studentList = studentList.stream().filter(distinctKey(Student::getName)).collect(Collectors.toList());
        System.out.println("去重后: " + studentList);
    }

    /**
     * @Description 自定义过滤器
     * @Param [keyExtractor]
     * @return java.util.function.Predicate<T>
     **/
    public static <T> Predicate<T> distinctKey(Function<? super T, Object> keyExtractor) {
        Map<Object, Boolean> map = new ConcurrentHashMap<>();
        return o -> map.putIfAbsent(keyExtractor.apply(o), Boolean.TRUE) == null;
    }

执行：

在这里插入图片描述

补充

补充一点，如何提取去重后的单元素集合：

public static void main(String[] args) {

        // 生成学生集合
        List<Student> studentList = new ArrayList<>();
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("张三", 19));
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("李四", 18));
        System.out.println("去重前: " + studentList);

        // 提取去重后的姓名
        List<String> nameList = studentList.stream().map(Student::getName).distinct().collect(Collectors.toList());
        System.out.println("去重后: " + nameList);
    }

执行：

在这里插入图片描述

多属性去重

方法一：利用map根据姓名、年龄去重
public static void main(String[] args) {

        // 生成学生集合
        List<Student> studentList = new ArrayList<>();
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("张三", 19));
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("李四", 18));
        System.out.println("去重前: " + studentList);

        // 利用map根据姓名、年龄去重
        Map<String, Student> map = new HashMap<>();
        for (Student student : studentList) {
            map.put(student.getName() + "_" + student.getAge(), student);
        }
        studentList = new ArrayList<>(map.values());
        System.out.println("去重后: " + studentList);
    }

执行：

在这里插入图片描述

方法二：利用map根据姓名、年龄去重，java 8写法
public static void main(String[] args) {

        // 生成学生集合
        List<Student> studentList = new ArrayList<>();
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("张三", 19));
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("李四", 18));
        System.out.println("去重前: " + studentList);

        // 利用map根据姓名、年龄去重，java 8写法
        studentList = studentList.stream()
                                 .collect(Collectors.toMap(s -> s.getName() + "_" + s.getAge(), Function.identity(), (o, n) -> n))
                                 .values()
                                 .stream().collect(Collectors.toList());
        System.out.println("去重后: " + studentList);
    }

执行：

在这里插入图片描述

方法三：利用Set根据姓名、年龄去重，java 8写法
public static void main(String[] args) {

        // 生成学生集合
        List<Student> studentList = new ArrayList<>();
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("张三", 19));
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("李四", 18));
        System.out.println("去重前: " + studentList);

        // 利用Set根据姓名、年龄去重，java 8写法
        studentList = studentList.stream().collect(Collectors.collectingAndThen(
                                                   Collectors.toCollection(
                                                           () -> new TreeSet<>(Comparator.comparing(o -> o.getName() + "_" + o.getAge()))
                                                   ), ArrayList::new));
        System.out.println("去重后: " + studentList);
    }

执行：

在这里插入图片描述

重写equals()和hashCode()方法

下面的几种方法首先需要在实体类中重写equals()和hashCode()方法

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

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
方法四：利用java 8 的distinct()，最推荐
 public static void main(String[] args) {

        // 生成学生集合
        List<Student> studentList = new ArrayList<>();
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("张三", 19));
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("李四", 18));
        System.out.println("去重前: " + studentList);

        // 利用java 8 的distinct()，根据姓名和年龄去重
        studentList = studentList.stream().distinct().collect(Collectors.toList());
        System.out.println("去重后: " + studentList);
    }

执行：

在这里插入图片描述

方法五：通过contains()方法来调用equals()方法来对比
 public static void main(String[] args) {

        // 生成学生集合
        List<Student> studentList = new ArrayList<>();
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("张三", 19));
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("李四", 18));
        System.out.println("去重前: " + studentList);

        // 通过contains()方法来调用equals()方法来对比，根据姓名和年龄去重
        List<Student> newStudentList = new ArrayList<>();
        for (Student student : studentList) {
            if (!newStudentList.contains(student)) {
                newStudentList.add(student);
            }
        }
        System.out.println("去重后: " + newStudentList);
    }

执行：

在这里插入图片描述

方法六：重写方法后，通过Set去重
 public static void main(String[] args) {

        // 生成学生集合
        List<Student> studentList = new ArrayList<>();
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("张三", 19));
        studentList.add(new Student("张三", 18));
        studentList.add(new Student("李四", 18));
        System.out.println("去重前: " + studentList);

        // 通过Set，根据姓名和年龄去重
       Set<Student> set = new HashSet<>(studentList);
       studentList.clear();
       studentList.addAll(set);
        System.out.println("去重后: " + studentList);
    }

执行：

在这里插入图片描述
完结撒花！！！
在这里插入图片描述

古阙月
关注
  • 29
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java List中数据的去重
08-26
如果List集合中的数据类型是对象类型，如People等，我们需要在对象的实体类中重写equals()方法和hashCode()方法。这样，Set集合才能正确地去除重复的元素。例如： ```java public class People { private String ...
如何实现java8 list按照元素的某个字段去重
08-25
为了基于特定字段去重，我们可以创建一个辅助工具类`StreamUtil`，提供一个`distinctByKey`方法，该方法返回一个谓词（Predicate），用于检查元素的特定字段是否已经出现过： ```java public class StreamUtil { ...
Java【List】去重的 6种方法
热门推荐
简单发点工作中用到的，或者记录下小知识点
11-09 5万+
Set集合去重，JDK8特性去重，迭代器去重和List自带contains去重
Java 去除重复数据的五种方式
狼魂之力
09-16 1万+
1.使用LinkedHashSet删除arraylist中的重复数据 LinkedHashSet是在一个ArrayList删除重复数据的最佳方法。LinkedHashSet在内部完成两件事： 删除重复数据 保持添加到其中的数据的顺序 Java示例使用LinkedHashSet删除arraylist中的重复项。在给定的示例中，numbersList是包含整数的arraylist，其中一些是重复的数字。 例如1,3和5.我们将列表添加到LinkedHashSet，然后将内容返回到列表中。结果arraylist没
Java去重秘籍：5分钟精通4大高级技巧，告别繁琐重复
最新发布
java专栏
05-24 712
对于复杂对象（非基础类型或String），可能需要自定义比较逻辑来确定元素是否重复。int age;// 姓名相同，年龄不同 // 使用Comparator自定义去重逻辑，这里简单地基于姓名去重 List < Person > uniquePeople = people . stream() . filter(distinctByKey(p -> p . name)) . collect(Collectors . toList());
Java怎么去重
weixin_35751194的博客
01-03 1618
要在 Java 中去重，你可以使用以下方法之一： 使用 Set：Set 是 Java 中的一种数据结构，它不允许重复元素。你可以把你的列表转换为 Set，这样就可以去除重复元素了。 使用流式处理：Java 8 中提供了一个流式处理的 API，你可以使用它来筛选出列表中的不重复元素。例如： List<Integer> list = Arrays.asList(1, 2, 3, 3...
Java实现数组去重复的18种写法
07-21 6514
数组(含List)去重复在日常工作中经常遇到，很多时候用到Set数据结构，但有时候我们需要针对数据进行干预，这时候就需要用其他的实现方式了。以下列出各种的去重方式，基本含括了所有情况。
java8集合去重方法
一个叫楚歌的程序媛
07-01 6821
文章目录前言一、应用场景二、使用方法1.TreeSet排序去重2.使用方法判断重复ID总结 前言 一、应用场景 使用List添加一系列对象，需要根据对象的ID属性进行list去重。 二、使用方法 经过验证，以下两种方法有效，第一种方法更简洁。 1.TreeSet排序去重 代码如下： import Java.util.Comparator; import Java.util.stream.Collectors; import Java.util.TreeSet; dsEntityList=dsEntityLi
Java 得到集合中所有子集
08-31
在Java编程中，得到集合中所有子集是一个常见的算法问题，尤其在数据结构和算法面试中经常出现。本文将深入探讨如何使用Java实现这一功能，同时解析相关知识点。 首先，我们要明白子集的概念。在数学中，如果一个...
java中List对象列表实现去重或取出及排序的方法
08-29
在Java中，想要去重List对象列表，首先需要重写实体类的equals和hashCode方法。equals方法用于比较两个对象是否相同，而hashCode方法用于计算对象的哈希码值。 例如，假设我们有一个Student类，想要去重Student对象...
my-tools:好用的Java工具类
06-18
2. **集合操作**：集合是Java编程中不可或缺的部分，工具类可能会提供一些高级的集合操作，例如快速查找、排序、去重、转换等。 3. **日期时间**：对日期和时间的操作是常见的需求，工具类可能会提供易于使用的API...
Java之常用去重方法
CharlesYan的博客
02-18 1万+
Java之常用去重方法常规元素去重常用去重6大方法方式1：遍历原List赋值给新List(保持原序)方式2：Set集合去重(保持原序)方式3：Set集合去重——HashSet(原序打乱)方式4：Set集合去重——TreeSet(按字典顺序重排序)方式5：Set集合去重——LinkedHashSet(保持原序)方式6：Java8新特性Stream实现去重(保持原序)自定义对象去重常用去重3大方法方式...
java常用的五种数据去重方式
晚笛的博客
03-28 2873
java常用的五种数据去重方式
JAVA8 List的去重、过滤、映射(map)、分组、统计(sum、max、min、avg)、分页
ACGkaka的博客
03-20 1万+
目录 1.实现List对象集合的简单去重（distinct()） 2.实现List集合的根据属性（name）去重 3.实现List对象集合的简单过滤（过滤为 null 的对象） 4.实现List对象集合中获取其中某一属性（weight）的List集合 5.实现List对象集合中根据对象（Apple）的某一属性（color）进行分组 6.实现List对象集合中求和、最大、最小、平均的统计...
Java List＜实体类＞ 单字段，多字段去重，条件过滤
qq_37739437的博客
06-07 2506
1 取出 List 集合中 name 作为 list 2 过滤集合中 名称重复的数据 单个字段重复时过滤 3 根据某字段过滤 4 整个对象字段完全相同去重
Java集合去重的几种方法
qinxun2008081的博客
06-13 3263
Java集合去重的几种方法
Java去重的终极指南：性能对比与高效实现
加辣椒了吗?的博客
07-10 1243
在日常的Java开发中，去重是一个常见的操作。对于一个包含重复元素的集合，我们常常需要去除重复元素，以便进行后续的处理。本文将介绍几种常用的Java去重方式，并进行性能对比。使用HashMap实现的Set，不保证元素的顺序，是最快的去重方法。本文介绍了Java中几种常用的去重方式，包括使用Set接口、Stream API、Apache Commons Collections库等。根据实际需求和性能考量选择合适的方法，可以提高程序的效率和可维护性，满足各种去重需求。
JAVA8 获取list集合中重复的元素和获取去重数据
qq_41128049的博客
09-30 2万+
JAVA8 获取list集合中重复的元素和获取去重数据。
Java中，Map、List集合遍历、去重方式超详细总结
weixin_55746254的博客
07-16 4353
Java面试总结，Java集合常问内容，集合的基本概念，Map集合去重、List集合去重
list实体类集合去重
12-07
以下是两种Java集合类中List实体类集合去重的例子： 1.根据多个字段去重 ```java List<ResourcesData> distinctClass = resourcesDataList.stream() .collect(Collectors.collectingAndThen( Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(o -> o.getSkill() + ";" + o.getTechLevel()))), ArrayList::new)); ``` 2.普通版 ```java projectList = projectList.stream().distinct().collect(Collectors.toList()); ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值