Java List的Distinct操作：深入解析与应用

孔乙己大叔

于 2024-09-04 20:10:21 发布

阅读量1.1k

点赞数 30

分类专栏： Java 学习文章标签： distinct方法 Java List 去重 equals和hashCode 自定义对象去重 Stream API

本文链接：https://blog.csdn.net/Ctrl_qun/article/details/141902693

版权

Java 学习专栏收录该内容

13 篇文章 0 订阅

订阅专栏

更多内容个人网站：孔乙己大叔

在Java编程中，处理集合数据是一项基础且重要的任务。特别是当处理包含大量重复元素的List时，如何高效地提取唯一的元素变得尤为关键。Java 8引入的Stream API极大地简化了这一过程，其中distinct()方法便是一个用于去重的强大工具。本文将深入探讨Java List的distinct()操作，通过详细的代码示例、数据可视化以及应用场景的讨论，帮助读者全面理解并掌握这一技能。

一、List与Distinct的基本概念

1.1 List简介

List是Java集合框架（Java Collections Framework）中的一个接口，它继承自Collection接口。List是一种有序集合，允许我们存储元素并保留元素的插入顺序。List接口的实现类有很多，如ArrayList、LinkedList等，它们各自在性能上有所差异，但基本功能相似。

1.2 Distinct的意义

在数据处理的上下文中，“distinct”一词通常指的是从一组数据中提取出不重复的元素集合。在数据库查询中，我们经常使用SELECT DISTINCT语句来实现这一目的。而在Java中，虽然没有直接的distinct关键字，但Stream API提供的distinct()方法能够轻松地实现相同的功能。

二、List与Distinct的基本用法

2.1 引入Stream API

Java 8引入的Stream API提供了一种高效处理集合（包括List）的方式。Stream可以看作是一个来自数据源的元素队列并支持聚合操作。与Collection相比，Stream不存储元素，而是对数据源进行操作，并在需要时计算源元素的聚合结果。

2.2 使用Stream和distinct()去重

要从List中去除重复元素，我们可以将List转换为Stream，然后调用distinct()方法。distinct()方法会返回一个包含不同元素的流，随后我们可以使用collect(Collectors.toList())将这个流收集到一个新的List中。

示例代码：

import java.util.Arrays;  
import java.util.List;  
import java.util.stream.Collectors;  
  
public class ListDistinctExample {  
    public static void main(String[] args) {  
        List<String> items = Arrays.asList("apple", "banana", "apple", "orange", "banana", "grape");  
  
        // 使用Stream和distinct()去重  
        List<String> distinctItems = items.stream()  
                .distinct()  
                .collect(Collectors.toList());  
  
        System.out.println("Distinct items: " + distinctItems);  
    }  
}

在上述代码中，我们首先创建了一个包含重复元素的List items。然后，我们调用stream()方法将其转换为Stream，接着调用distinct()方法去除重复元素，并使用collect(Collectors.toList())将结果收集到一个新的List distinctItems中。最后，我们打印出这个新的List，它只包含不重复的元素。

三、深入理解Distinct的实现原理

3.1 依赖equals()和hashCode()

distinct()方法去重的依据是元素的equals()和hashCode()方法。当Stream在内部比较两个元素是否相等时，它会首先调用这两个元素的hashCode()方法。如果两个元素的哈希码相同，那么Stream会进一步调用它们的equals()方法来确认它们是否相等。因此，如果你想要对自定义对象进行去重，确保正确实现了这两个方法是非常重要的。

3.2 底层实现机制

在底层，distinct()方法可能使用了HashSet（或其他类似的数据结构）来存储已经遇到的元素。这样，每当遇到一个新元素时，它都会检查这个元素是否已经被存储在HashSet中。如果没有，就将其添加到HashSet中，并将其包含在最终的结果中；如果已经存在，则忽略它。

需要注意的是，由于HashSet不保证元素的顺序，因此distinct()方法返回的流（以及收集到的新List）中的元素顺序可能与原始List中的顺序不同。然而，对于大多数去重场景来说，这通常是可以接受的。

四、自定义对象的去重

4.1 重写equals()和hashCode()

当你需要对自定义对象进行去重时，确保你已经正确重写了equals()和hashCode()方法。这两个方法必须保持一致性，即如果两个对象通过equals()方法比较相等，那么它们的hashCode()方法必须返回相同的值。

示例代码：

import java.util.Arrays;  
import java.util.List;  
import java.util.Objects;  
import java.util.stream.Collectors;  
  
class Person {  
    String name;  
    int age;  
  
    // 构造函数、getter和setter省略  
  
    @Override  
    public boolean equals(Object o) {  
        if (this == o) return true;  
        if (o == null || getClass() != o.getClass()) return false;  
        Person person = (Person) o;  
        return age == person.age &&  
               Objects.equals(name, person.name);  
    }  
  
    @Override  
    public int hashCode() {  
        return Objects.hash(name, age);  
    }  
  
    // toString()方法用于打印对象信息，方便查看结果  
    @Override  
    public String toString() {  
        return "Person{" +  
               "name='" + name + '\'' +  
               ", age=" + age +  
               '}';  
    }  
}  
  
public class CustomObjectDistinctExample {  
    public static void main(String[] args) {  
        List<Person> people = Arrays.asList(  
                new Person("Alice", 30),  
                new Person("Bob", 25),  
                new Person("Alice", 30) // 注意这里有一个重复的元素  
        );  
  
        List<Person> distinctPeople = people.stream()  
                .distinct()  
                .collect(Collectors.toList());  
  
        System.out.println("Distinct People: " + distinctPeople);  
    }  
}

在上述代码中，我们定义了一个Person类，并为其重写了equals()和hashCode()方法。然后，我们创建了一个包含重复Person对象的List，并使用distinct()方法去除重复元素。最后，我们打印出去重后的List，可以看到只有一个Alice对象被保留了下来。

4.2 使用Collectors.toMap()进行自定义去重

有时候，我们可能需要根据对象的某个特定属性进行去重。例如，我们可能只想保留每个Person对象的name属性唯一的记录。在这种情况下，我们可以使用Collectors.toMap()方法，将对象的某个属性作为键，将对象本身或对象的某个部分作为值。然后，我们可以使用values()方法从Map中获取去重后的元素集合。

示例代码：

import java.util.*;  
import java.util.function.Function;  
import java.util.stream.Collectors;  
  
// 假设Person类已经定义并实现了equals()和hashCode()  
  
public class CustomDistinctByPropertyExample {  
    public static void main(String[] args) {  
        List<Person> people = Arrays.asList(  
                new Person("Alice", 30),  
                new Person("Bob", 25),  
                new Person("Alice", 35) // 注意这里Alice的age不同  
        );  
  
        // 使用Collectors.toMap()根据name属性去重，保留第一个遇到的Person对象  
        Map<String, Person> distinctByName = people.stream()  
                .collect(Collectors.toMap(  
                        Person::getName, // keyMapper，提取键（即name属性）  
                        Function.identity(), // valueMapper，使用对象本身作为值  
                        (existing, replacement) -> existing // mergeFunction，当键冲突时保留哪个值（这里保留第一个）  
                ));  
  
        // 从Map中提取去重后的Person对象集合  
        List<Person> distinctPeople = new ArrayList<>(distinctByName.values());  
  
        System.out.println("Distinct People by Name: " + distinctPeople);  
    }  
}

在上述代码中，我们使用Collectors.toMap()方法根据Person对象的name属性进行去重。当遇到键冲突时（即两个Person对象具有相同的name），我们通过mergeFunction指定保留哪个对象（在这个例子中，我们保留了第一个遇到的对象）。然后，我们使用values()方法从Map中提取出去重后的Person对象集合。

五、性能考虑与最佳实践

5.1 性能考虑

虽然distinct()方法提供了便捷的去重功能，但在处理大量数据时，其性能可能会受到影响。因为distinct()方法可能需要将所有元素存储在一个内部数据结构（如HashSet）中，以便检查元素是否重复。如果List中的元素数量非常大，那么这个过程可能会消耗大量的内存和计算资源。

因此，在处理大型数据集时，你应该考虑其他去重策略，如使用数据库的唯一索引、在数据入库前进行去重处理或使用并行流（Parallel Streams）来加速处理过程。

5.2 最佳实践

确保equals()和hashCode()的一致性：当对自定义对象进行去重时，务必确保你已经正确重写了equals()和hashCode()方法，并且这两个方法保持一致。
考虑数据的顺序：distinct()方法不保证结果的顺序与原始List中的顺序相同。如果你需要保持元素的顺序，你可能需要使用其他方法（如LinkedHashSet）来手动实现去重。

孔乙己大叔您的一站式代码技术资源中心。我们汇集了各种编程语言的教程、最佳实践和行业解决方案，帮助您轻松掌握最新技术。此外，我们还提供了一系列实用的开发者工具和代码库，助您提升开发效率。立即访问，探索更多精彩内容！http://www.rebootvip.com/