【Java】List集合对象去重及按属性去重的多种方法

最新推荐文章于 2025-04-13 00:34:00 发布
最新推荐文章于 2025-04-13 00:34:00 发布
阅读量3.7k 收藏 23
点赞数 34
分类专栏： # Java 文章标签： java list windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/g310773517/article/details/141431041
版权

在Java中，List集合是常用的数据结构之一。在实际开发中，我们经常需要对List集合进行去重操作，特别是按某个属性进行去重。本文将详细介绍几种在Java中对List集合对象去重及按属性去重的方法，并提供一些实用的示例代码。

🧑 博主简介：
现任阿里巴巴嵌入式技术专家，15年工作经验，深耕嵌入式+人工智能领域，精通嵌入式领域开发、技术管理、简历招聘面试。CSDN优质创作者，提供产品测评、学习辅导、简历面试辅导、毕设辅导、项目开发、C/C++/Java/Python/Linux/AI等方面的服务，如有需要请站内私信或者联系任意文章底部的的VX名片（ID：gylzbk）

💬 博主粉丝群介绍：① 群内初中生、高中生、本科生、研究生、博士生遍布，可互相学习，交流困惑。② 热榜top10的常客也在群里，也有数不清的万粉大佬，可以交流写作技巧，上榜经验，涨粉秘籍。③ 群内也有职场精英，大厂大佬，可交流技术、面试、找工作的经验。④ 进群免费赠送写作秘籍一份，助你由写作小白晋升为创作大佬。⑤ 进群赠送CSDN评论防封脚本，送真活跃粉丝，助你提升文章热度。有兴趣的加文末联系方式，备注自己的CSDN昵称，拉你进群，互相学习共同进步。

在这里插入图片描述

【Java】List集合对象去重及按属性去重的多种方法

在这里插入图片描述

1. 使用 Set 进行去重

Set 是一种不允许重复元素的集合，可以利用它的这一特性对 List 进行去重。

1.1 使用 HashSet 进行去重

示例代码：

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class ListDeduplication {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        list.add("apple");
        list.add("orange");

        Set<String> set = new HashSet<>(list);
        List<String> deduplicatedList = new ArrayList<>(set);

        System.out.println(deduplicatedList);  // 输出: [banana, orange, apple]
    }
}

2. 使用 LinkedHashSet 保持顺序去重

LinkedHashSet 是 HashSet 的子类，具有 HashSet 的去重特性，同时保留元素的插入顺序。

示例代码：

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

public class ListDeduplication {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        list.add("apple");
        list.add("orange");

        Set<String> set = new LinkedHashSet<>(list);
        List<String> deduplicatedList = new ArrayList<>(set);

        System.out.println(deduplicatedList);  // 输出: [apple, banana, orange]
    }
}

3. 使用 Stream API 进行去重

Java 8 引入了 Stream API，使得去重操作更加简洁。

示例代码：

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class ListDeduplication {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        list.add("apple");
        list.add("orange");

        List<String> deduplicatedList = list.stream().distinct().collect(Collectors.toList());

        System.out.println(deduplicatedList);  // 输出: [apple, banana, orange]
    }
}

4. 按属性去重

对于对象集合，可以按某个属性进行去重。

4.1 使用 HashSet 和 Stream API 按属性去重

假设有一个包含 Person 对象的 List，按 name 属性进行去重。

示例代码：

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

class Person {
    String name;
    int age;

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

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

public class ListDeduplication {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("Alice", 30));
        list.add(new Person("Bob", 25));
        list.add(new Person("Alice", 35));
        list.add(new Person("Charlie", 40));

        Set<String> seenNames = new HashSet<>();
        List<Person> deduplicatedList = list.stream()
            .filter(person -> seenNames.add(person.name))
            .collect(Collectors.toList());

        System.out.println(deduplicatedList);
        // 输出: [Person{name='Alice', age=30}, Person{name='Bob', age=25}, Person{name='Charlie', age=40}]
    }
}

4.2 使用 Collectors.toMap 按属性去重

示例代码：

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class Person {
    String name;
    int age;

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

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

public class ListDeduplication {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("Alice", 30));
        list.add(new Person("Bob", 25));
        list.add(new Person("Alice", 35));
        list.add(new Person("Charlie", 40));

        Map<String, Person> deduplicatedMap = list.stream()
            .collect(Collectors.toMap(person -> person.name, person -> person, (existing, replacement) -> existing));
        
        List<Person> deduplicatedList = new ArrayList<>(deduplicatedMap.values());

        System.out.println(deduplicatedList);
        // 输出: [Person{name='Alice', age=30}, Person{name='Bob', age=25}, Person{name='Charlie', age=40}]
    }
}

5. 使用 Comparator 和 TreeSet 按属性去重

TreeSet 是一个有序的集合，可以通过自定义 Comparator 来实现按属性去重。

示例代码：

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

class Person {
    String name;
    int age;

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

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

public class ListDeduplication {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("Alice", 30));
        list.add(new Person("Bob", 25));
        list.add(new Person("Alice", 35));
        list.add(new Person("Charlie", 40));

        Set<Person> deduplicatedSet = new TreeSet<>(Comparator.comparing(person -> person.name));
        deduplicatedSet.addAll(list);

        List<Person> deduplicatedList = new ArrayList<>(deduplicatedSet);

        System.out.println(deduplicatedList);
        // 输出: [Person{name='Alice', age=30}, Person{name='Bob', age=25}, Person{name='Charlie', age=40}]
    }
}

6. 使用 LinkedHashMap 按属性去重

LinkedHashMap 是一个有序的映射，可以通过 key 来实现按属性去重，并保持插入顺序。

示例代码：

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

class Person {
    String name;
    int age;

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

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

public class ListDeduplication {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("Alice", 30));
        list.add(new Person("Bob", 25));
        list.add(new Person("Alice", 35));
        list.add(new Person("Charlie", 40));

        Map<String, Person> deduplicatedMap = new LinkedHashMap<>();
        for (Person person : list) {
            deduplicatedMap.putIfAbsent(person.name, person);
        }

        List<Person> deduplicatedList = new ArrayList<>(deduplicatedMap.values());

        System.out.println(deduplicatedList);
        // 输出: [Person{name='Alice', age=30}, Person{name='Bob', age=25}, Person{name='Charlie', age=40}]
    }
}

7. 使用 Collectors.collectingAndThen 和 toCollection

结合 Collectors.collectingAndThen 和 toCollection 方法，可以在流操作中自定义集合的类型。

示例代码：

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

class Person {
    String name;
    int age;

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

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

public class ListDeduplication {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("Alice", 30));
        list.add(new Person("Bob", 25));
        list.add(new Person("Alice", 35));
        list.add(new Person("Charlie", 40));

        List<Person> deduplicatedList = list.stream()
            .collect(Collectors.collectingAndThen(
                Collectors.toMap(person -> person.name, person -> person, (existing, replacement) -> existing),
                map -> new ArrayList<>(map.values())
            ));

        System.out.println(deduplicatedList);
        // 输出: [Person{name='Alice', age=30}, Person{name='Bob', age=25}, Person{name='Charlie', age=40}]
    }
}

8. 使用 Guava 库的 Sets.newLinkedHashSet

Google 的 Guava 库提供了丰富的集合工具，可以使用 Sets.newLinkedHashSet 保持顺序去重。

示例代码：

import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

class Person {
    String name;
    int age;

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

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

public class ListDeduplication {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("Alice", 30));
        list.add(new Person("Bob", 25));
        list.add(new Person("Alice", 35));
        list.add(new Person("Charlie", 40));

        Set<Person> deduplicatedSet = Sets.newLinkedHashSet(list);
        List<Person> deduplicatedList = new ArrayList<>(deduplicatedSet);

        System.out.println(deduplicatedList);
        // 输出: [Person{name='Alice', age=30}, Person{name='Bob', age=25}, Person{name='Charlie', age=40}]
    }
}

9. 使用 Apache Commons Collections 的 CollectionUtils

Apache Commons Collections 提供了丰富的集合工具，可以使用 CollectionUtils 进行去重。

示例代码：

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.Transformer;

import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

class Person {
    String name;
    int age;

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

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

public class ListDeduplication {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("Alice", 30));
        list.add(new Person("Bob", 25));
        list.add(new Person("Alice", 35));
        list.add(new Person("Charlie", 40));

        Collection<Person> deduplicatedCollection = CollectionUtils.collect(
            new LinkedHashSet<>(list),
            new Transformer<Person, Person>() {
                public Person transform(Person person) {
                    return person;
                }
            }
        );

        List<Person> deduplicatedList = new ArrayList<>(deduplicatedCollection);

        System.out.println(deduplicatedList);
        // 输出: [Person{name='Alice', age=30}, Person{name='Bob', age=25}, Person{name='Charlie', age=40}]
    }
}

10. 使用 Map 的 computeIfAbsent 方法

通过 Map 的 computeIfAbsent 方法，可以在构建过程中去重。

示例代码：

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

class Person {
    String name;
    int age;

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

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

public class ListDeduplication {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("Alice", 30));
        list.add(new Person("Bob", 25));
        list.add(new Person("Alice", 35));
        list.add(new Person("Charlie", 40));

        Map<String, Person> deduplicatedMap = new LinkedHashMap<>();
        for (Person person : list) {
            deduplicatedMap.computeIfAbsent(person.name, k -> person);
        }

        List<Person> deduplicatedList = new ArrayList<>(deduplicatedMap.values());

        System.out.println(deduplicatedList);
        // 输出: [Person{name='Alice', age=30}, Person{name='Bob', age=25}, Person{name='Charlie', age=40}]
    }
}

11. 使用 Collectors.groupingBy 和 Collectors.reducing 方法

通过 Collectors.groupingBy 和 Collectors.reducing 方法，可以对对象集合按属性去重并进行聚合操作。

示例代码：

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class Person {
    String name;
    int age;

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

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

public class ListDeduplication {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("Alice", 30));
        list.add(new Person("Bob", 25));
        list.add(new Person("Alice", 35));
        list.add(new Person("Charlie", 40));

        Map<String, Person> deduplicatedMap = list.stream()
            .collect(Collectors.groupingBy(
                person -> person.name,
                Collectors.reducing((p1, p2) -> p1)
            ))
            .entrySet()
            .stream()
            .filter(entry -> entry.getValue().isPresent())
            .collect(Collectors.toMap(Map.Entry::getKey, entry -> entry.getValue().get()));

        List<Person> deduplicatedList = new ArrayList<>(deduplicatedMap.values());

        System.out.println(deduplicatedList);
        // 输出: [Person{name='Alice', age=30}, Person{name='Bob', age=25}, Person{name='Charlie', age=40}]
    }
}

12. 使用第三方库 StreamEx

StreamEx 是一个增强版的 Java 8 Stream API，通过 distinct 方法可以方便地按属性去重。

示例代码：

import one.util.streamex.StreamEx;

import java.util.ArrayList;
import java.util.List;

class Person {
    String name;
    int age;

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

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

public class ListDeduplication {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("Alice", 30));
        list.add(new Person("Bob", 25));
        list.add(new Person("Alice", 35));
        list.add(new Person("Charlie", 40));

        List<Person> deduplicatedList = StreamEx.of(list)
            .distinct(Person::getName)
            .toList();

        System.out.println(deduplicatedList);
        // 输出: [Person{name='Alice', age=30}, Person{name='Bob', age=25}, Person{name='Charlie', age=40}]
    }
}

总结

通过以上示例，我们展示了在 Java 中对 List 集合对象进行去重及按属性去重的多种方法，包括使用 Set、Stream API、TreeSet、LinkedHashMap、Guava、Apache Commons Collections、Map 的 computeIfAbsent 方法、Collectors.groupingBy 和 Collectors.reducing 方法以及第三方库 StreamEx 等。这些方法各有特点，可以根据具体需求选择合适的方法进行去重操作。

Java项目中list集合的7种去重方法
tigerhhzz的博客
12-13 488
新建一个集合，然后循环原来的集合，每次循环判断原集合中的循环项，如果当前循环的数据，没有在新集合中存在就插入，已经存在了就舍弃，就得到了一个没有重复元素的集合了。使用迭代器循环判断每一项数据，如果当前循环的数据，在集合中存在两份或两份以上，就将当前的元素删除掉，这样循环完之后，即可得到一个没有重复数据的集合。JDK 8 为我们带来了一个非常实用的方法 Stream，使用它可以实现很多功能。（个人感觉Stream非常nice好用）
java中List对象列表实现去重或取出及排序的方法
08-29
Java中List对象列表实现去重或取出及排序的方法 在Java中，对List对象列表实现去重或取出及排序是一种常见的操作。下面将详细介绍相关的方法和实现。 1. 实体类重写equals和hashCode方法 在Java中，想要去重List...
Java List 集合对象去重
weixin_42262791的博客
04-17 493
建个工具类 重写方法实现集合对象去重 比较实用 /** * 根据某个字段去重 * * @param carList * @return * @author preference */ public static List<Car> distinctBycar(List<Car> carList...
java list根据对象的某个属性的值去重
09-25
java list根据对象的某个属性的值去重，java list根据对象的某个属性的值去重java list根据对象的某个属性的值去重
java中的List集合去重
最新发布
qq_45089709的博客
04-13 546
在 Java 里，有多种方法可以对List。
Java中List集合对象去重及按属性去重的8种方法
09-08
主要介绍了Java中List集合对象去重及按属性去重的8种方法,本文给大家介绍的非常详细，对大家的学习或工作具有一地的参考借鉴价值，需要的朋友可以参考下
java List对象集合中 如何根据集合中对象某几个属性组合去重
wujian_csdn_csdn的博客
10-25 2377
利用Java 8的Stream API，可以简化代码。你可以创建一个自定义类，并为这个类实现equals()和hashCode()方法。然后使用HashSet来存储这些对象，因为HashSet不允许重复元素。这里，键是属性组合的字符串表示形式，而值则是MyClass对象本身。请注意这种方法可能不会保持元素的原始顺序。如果需要根据特定属性去重，可以使用distinct()结合Comparator或更复杂的逻辑。
Java中List集合对象去重及按属性去重七种方法
浮沉往事意朦胧
04-18 1万+
Java中List集合对象去重及按属性去重七种方法
List 如何根据对象的属性去重？Java 8 轻松搞定！
Java笔记虾
03-11 1369
点击关注公众号，利用碎片时间学习一、去除List中重复的StringpublicList<String>removeStringListDupli(List<Stri...
Java中对List去重 Stream去重的解决方法
08-27
Java中提供了多种方法来实现List去重，下面我们将对其中的一些方法进行介绍。 使用HashSet去重 HashSet是一种常见的集合类型，它具有自动去重的特性。我们可以将List中的元素添加到HashSet中，然后从HashSet中...
list集合根据对象属性去重
haohaounique的博客
04-26 759
场景：根据list对象中的某几个属性（非空）去重，保留唯一值 思路：将属性组成唯一键，然后去重 示例：重复添加某个对象然后测试 import lombok.Data; import java.util.ArrayList; import java.util.Comparator; import java.util.List; import java.util.TreeSet; import static java.util.stream.Collectors.collectingAndThe.
JAVA——list对象如何根据对象的多个属性（部分属性）进行去重
Colin的博客
07-15 1196
利用contains方法进行去重。订单实体类order中存在十几个属性，若客户名称、产品名称和联系电话相同则判断为同一订单，需要对list中相同订单进行去重。3、遍历原始的List对象，对于每一个元素，使用contains方法判断新List中是否已经存在该元素。4、如果新List中不存在该元素，则将该元素添加到新List中。5、最后，新List中的元素就是去重后的结果。1、创建一个简化版订单实体类（只包含需要比较去重的属性）。2、创建一个新的List对象，用于存放去重后的元素。
List集合对象去重及按属性去重的8种方法
热门推荐
字母哥博客
09-07 3万+
最近在写一些关于java基础的文章，但是我又不想按照教科书的方式去写知识点的文章，因为意义不大。基础知识太多了，如何将这些知识归纳总结，总结出优缺点或者是使用场景才是对知识的升华。所以我更想把java相关的基础知识进行穿针引线，进行整体上的总结。 总结java中创建并写文件的5种方式 总结java从文件中读取数据的6种方法 总结java创建文件夹的4种方法及其优缺点 总结java中删除文件或文件夹的7种方法 总结java中文件拷贝剪切的5种方式 比如之前我已经写了上面的这些内容，如果对java基础知识.
Java中List集合对象去重及按属性去重
liuerchong的博客
03-02 2601
集合元素整体去重 以List中的String类型以集合元素对象为单位整体去重为例。如果List放入的是Object对象，需要你去实现对象的equals和hashCode方法，去重的代码实现方法和List去重是一样的。 先把List数据放入Set，因为Set数据结构本身具有去重的功能，所以再将SET转为List之后就是去重之后的结果。这种方法在去重之后会改变原有的List元素顺序，因为HashSet本身是无序的，而TreeSet排序也不是List种元素的原有顺序。 @Test void testRemove1
《Java基础：List 去重方式（6种）》
大大大钢琴
07-23 7612
List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下 >标）来访问List中的元素，这类似于Java的数组。总结（1）所有的List中只能容纳单个不同类型的对象组成的表，而不是Key－Value键值对。例如：[ tom,1,c ]（2）所有的List中可以有相同的元素，例如Vector中可以有 [ tom,koo,too,koo ]（3）所有的List中可以有null元素，例如[ tom,null,1 ]
list对象根据对象属性去重
xiansibao的博客
07-02 1298
例如，我们有一个实体类student，其中包含属性id、name和age，现在我们有一个List<Student>，我们希望根据name属性去除重复的Student对象。我们可以借助HashSet的特性，来实现根据对象属性去重。我们创建一个HashSet来存放对象的属性值，然后遍历List，根据属性值判断是否添加到HashSet，最后将HashSet转换成List。利用Java 8引入的Stream API，结合lambda表达式，更优雅地实现根据对象属性去重。
机房布线的最高境界……
weixin_44421461的博客
08-29 698
点击上方“Java基基”，选择“设为星标”做积极的人，而不是积极废人！源码精品专栏原创 | Java 2020超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析...
java中list集合对象去重
01-06
以下是两种Java中List集合对象去重的方法： 1. 使用双重循环遍历并删除重复元素： ```java public static List removeDuplicate(List list) { for (int i = 0; i < list.size() - 1; i++) { for (int j = list.size() - 1; j > i; j--) { if (list.get(j).equals(list.get(i))) { list.remove(j); } } } return list; } ``` 2. 使用HashSet去重并保持顺序： ```java public static void removeDuplicateWithOrder(List list) { Set set = new HashSet(); List newList = new ArrayList(); for (Iterator iter = list.iterator(); iter.hasNext();) { Object element = iter.next(); if (set.add(element)) newList.add(element); } list.clear(); list.addAll(newList); System.out.println("remove duplicate " + list); } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

I'mAlex

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值