Java集合去重技巧全解析

今日不肯埋头，明日何以抬头！每日一句努力自己的话哈哈~哈喽，今天我将给大家带来一篇《Java集合去重方法详解》，主要内容是讲解等等，感兴趣的朋友可以收藏或者有更好的建议在评论提出，我都会认真看的！大家一起进步，一起学习！

使用HashSet去重是Java中最高效的方式，其原理基于元素的hashCode()和equals()方法；对于自定义对象，必须正确重写这两个方法以确保去重成功，否则会因哈希冲突或比较失效导致重复元素存在。

在Java中，要实现集合的去重，最直接且高效的方式就是利用Set接口的实现类，尤其是HashSet。它天生就设计用来存储不重复的元素，其底层机制保证了元素的唯一性。

解决方案

利用HashSet进行去重是Java中最常见且性能优良的实践。其核心在于Set接口的特性：不允许包含重复元素。当你尝试向HashSet中添加一个已经存在的元素时，add()方法会返回false，且不会真的添加该元素。

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

public class DeduplicationExample {

    public static void main(String[] args) {
        // 示例1: 去重字符串列表
        List<String> stringList = new ArrayList<>();
        stringList.add("Apple");
        stringList.add("Banana");
        stringList.add("Apple"); // 重复
        stringList.add("Orange");
        stringList.add("Banana"); // 重复

        System.out.println("原始字符串列表: " + stringList); // 输出: [Apple, Banana, Apple, Orange, Banana]

        Set<String> uniqueStrings = new HashSet<>(stringList);
        System.out.println("去重后的字符串集合: " + uniqueStrings); // 输出: [Apple, Orange, Banana] (顺序可能不同)

        // 如果需要返回List类型
        List<String> distinctStringList = new ArrayList<>(uniqueStrings);
        System.out.println("去重后的字符串列表 (List): " + distinctStringList); // 输出: [Apple, Orange, Banana] (顺序可能不同)

        System.out.println("--------------------");

        // 示例2: 去重自定义对象列表
        List<Person> personList = new ArrayList<>();
        personList.add(new Person("Alice", 30));
        personList.add(new Person("Bob", 25));
        personList.add(new Person("Alice", 30)); // 逻辑上重复，但需要正确实现hashCode和equals
        personList.add(new Person("Charlie", 35));
        personList.add(new Person("Bob", 25)); // 逻辑上重复

        System.out.println("原始Person列表: " + personList);

        Set<Person> uniquePersons = new HashSet<>(personList);
        System.out.println("去重后的Person集合: " + uniquePersons);
        // 注意：如果Person类没有正确重写hashCode()和equals()，这里可能不会去重成功
        // 后面会详细讨论这一点
    }
}

class Person {
    String name;
    int age;

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

    // 为了演示去重，这里必须正确重写hashCode()和equals()
    @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 && name.equals(person.name);
    }

    @Override
    public int hashCode() {
        return name.hashCode() + age; // 简单的组合，实际应用中建议使用Objects.hash()
    }

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

这段代码展示了如何通过将一个包含重复元素的List直接传递给HashSet的构造器来快速完成去重。HashSet在内部会处理元素的唯一性，然后你可以选择将去重后的Set转换回List，如果你的业务逻辑需要。我个人在工作中，遇到大多数去重场景，HashSet几乎是首选，因为它在性能上表现均衡且API简洁。

为什么Set集合能天然实现去重？其底层原理是什么？

Set集合之所以能天然实现去重，其秘密在于它依赖于元素的hashCode()和equals()方法。当我们将元素添加到HashSet中时，它会执行以下几个步骤来判断元素是否重复：

1. 计算哈希码 (hashCode()): 首先，HashSet会调用待添加元素的hashCode()方法，计算出一个哈希码。这个哈希码决定了元素在底层哈希表中的存储位置（桶）。
2. 查找桶位: 根据哈希码找到对应的桶。如果这个桶是空的，那么元素就可以直接放进去，认为是新元素。
3. 比较 (equals()): 如果桶中已经有元素，HashSet不会直接认为它是重复的。它会遍历桶中的所有元素，并依次调用待添加元素的equals()方法与桶中已存在的每个元素进行比较。
   • 如果equals()方法返回true，则认为该元素已经存在，add()方法返回false，不会再添加。
   • 如果equals()方法对桶中所有元素都返回false，则认为该元素是新元素，将其添加到桶中。

所以，对于自定义对象，正确地重写hashCode()和equals()方法至关重要。我见过太多新手开发者，只重写了equals()，而忽略了hashCode()，结果导致HashSet无法正确识别重复对象，这是个非常常见的陷阱。Java规范明确指出：如果两个对象equals()返回true，那么它们的hashCode()也必须返回相同的值。反之则不一定。

除了Set，还有哪些去重方法？各自的适用场景是什么？

当然，除了Set，Java中还有其他几种去重的方法，它们各有优劣，适用于不同的场景：

1. Java 8 Stream API 的 distinct() 方法:

   • 特点: 这是处理集合去重最简洁、最现代的方式之一，尤其适用于链式操作。它也是基于hashCode()和equals()来判断重复的。
   • 适用场景: 当你已经在使用Stream API进行数据处理，或者希望用更函数式、声明式的方式去重时，distinct()是理想选择。它代码量少，可读性高。
   • 示例:

     List<String> names = Arrays.asList("Alice", "Bob", "Alice", "Charlie");
     List<String> distinctNames = names.stream().distinct().collect(Collectors.toList());
     System.out.println("Stream distinct: " + distinctNames); // 输出: [Alice, Bob, Charlie]

   • 我的看法: 对于中小型数据集，或者说当你需要对数据进行一系列转换后再去重时，distinct()非常优雅。但如果仅仅是去重，且数据量极大，HashSet的直接构建可能在某些极端情况下略有优势，因为Stream的管道处理会有一些额外的开销。

2. 手动遍历并检查 (contains()):

   • 特点: 这种方法通常效率最低，因为它在每次添加新元素时，都需要遍历已去重列表来检查是否存在。List的contains()方法在底层是线性查找。
   • 适用场景: 极少推荐，除非你的数据量非常小，或者有非常特殊的业务逻辑，比如在添加前需要执行一些复杂的判断，而不仅仅是equals()。
   • 示例:

     List<String> original = Arrays.asList("A", "B", "A", "C");
     List<String> unique = new ArrayList<>();
     for (String item : original) {
         if (!unique.contains(item)) { // 每次检查都是O(n)
             unique.add(item);
         }
     }
     System.out.println("手动contains去重: " + unique); // 输出: [A, B, C]

   • 我的看法: 这种方法我几乎不会在生产代码中使用，除非是面试题或者一些教学场景，它展示了去重最原始的逻辑，但性能瓶颈明显。

3. TreeSet 去重并排序:

   • 特点: TreeSet也是Set接口的实现，它不仅能去重，还能保证元素的自然排序或者根据自定义的Comparator进行排序。
   • 适用场景: 当你需要去重的同时，也希望结果是排序的，TreeSet是最佳选择。
   • 示例:

     List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6);
     Set<Integer> sortedUniqueNumbers = new TreeSet<>(numbers);
     System.out.println("TreeSet去重并排序: " + sortedUniqueNumbers); // 输出: [1, 2, 3, 4, 5, 6, 9]

   • 我的看法: TreeSet的性能开销通常比HashSet略高，因为它需要维护元素的排序。对于自定义对象，你需要确保它实现了Comparable接口，或者在构造TreeSet时提供一个Comparator。

处理复杂对象去重时，有哪些潜在的陷阱和最佳实践？

处理自定义（复杂）对象的去重，远比处理基本类型或String要复杂，因为涉及到对象相等性的定义。这里有一些常见的陷阱和我的最佳实践建议：

1. 未正确重写hashCode()和equals():

   • 陷阱: 这是最常见也是最致命的错误。如果你的自定义类没有正确重写这两个方法，HashSet或Stream.distinct()会默认使用Object类的实现，即比较对象的内存地址。这意味着即使两个对象在业务逻辑上是“相同”的（比如两个Person对象拥有相同的name和age），但只要它们是不同的实例，就会被认为是不同的元素。

   • 最佳实践:

     • 始终同时重写hashCode()和equals(): 这是Java规范的强制要求。如果equals()返回true，hashCode()必须返回相同的值。

     • 基于业务逻辑定义相等性: equals()方法应该根据你的业务需求来判断两个对象是否相等。例如，对于Person对象，可能name和age都相同才算相等。

     • hashCode()的实现要与equals()一致: hashCode()的计算应该基于equals()方法中用到的所有字段。Java 7及以后，可以使用Objects.hash()来简化hashCode()的实现，它能很好地处理null值。

     • 示例 (改进的Person类):

       import java.util.Objects; // 引入Objects类
       
       class Person {
           String name;
           int age;
           // ... (构造函数和toString不变)
       
           @Override
           public boolean equals(Object o) {
               if (this == o) return true;
               if (o == null || getClass() != o.getClass()) return false;
               Person person = (Person) o;
               // 使用Objects.equals处理可能为null的字段
               return age == person.age && Objects.equals(name, person.name);
           }
       
           @Override
           public int hashCode() {
               // 使用Objects.hash()生成哈希码，它会自动处理null字段
               return Objects.hash(name, age);
           }
       }

2. 可变对象作为Set元素:

   • 陷阱: 如果将一个可变对象（其内部状态在添加到Set后可能会改变）添加到HashSet中，并且其改变影响了hashCode()或equals()的结果，那么这个对象在Set中的行为会变得不可预测。你可能无法正确地删除它，或者Set会认为它不再存在，导致逻辑错误。
   • 最佳实践:
     • 优先使用不可变对象作为Set元素: 如果可能，确保作为Set元素的自定义对象是不可变的（所有字段都是final，并且没有提供修改这些字段的方法）。
     • 如果必须使用可变对象，请谨慎: 确保在对象添加到Set之后，任何影响hashCode()和equals()结果的字段都不会被修改。如果必须修改，你可能需要先将对象从Set中移除，修改后再重新添加。

3. 性能考量：hashCode()的分布性:

   • 陷阱: 一个设计糟糕的hashCode()方法可能会导致所有对象的哈希码都相同或非常相似。这会使得HashSet退化成一个链表，每次查找都需要遍历整个链表，导致时间复杂度从O(1)（平均）退化到O(n)（最坏），从而严重影响性能。
   • 最佳实践:
     • 设计一个分布均匀的hashCode(): 好的hashCode()应该让不同对象尽可能产生不同的哈希码，减少哈希冲突。Objects.hash()在这方面做得很好。
     • 避免使用不稳定的字段计算哈希码: 比如，不要用一个频繁变动的计数器字段来计算哈希码。

4. 使用自定义Comparator进行去重 (与Set略有不同):

   • 陷阱: 有时我们可能希望基于某些特定规则去重，而这些规则并不完全等同于对象的equals()方法。例如，我们可能认为两个Person对象只要name相同就认为是重复的，而忽略age。HashSet无法直接通过Comparator去重。
   • 最佳实践:
     • 如果需要自定义去重逻辑，并且不想修改equals()/hashCode(): 可以考虑使用Stream.collectingAndThen结合Collectors.toCollection和TreeSet，并提供一个自定义的Comparator。但请注意，TreeSet的去重是基于compareTo()（或Comparator.compare()）方法返回0来判断相等的。
     • 或者，创建一个包装类: 如果你的去重逻辑与原始对象的equals()/hashCode()不符，可以创建一个包装类，让这个包装类实现你想要的equals()/hashCode()逻辑，然后将包装类对象放入Set中去重。

总的来说，处理复杂对象的去重，核心在于对Java对象相等性契约（hashCode()和equals()）的深刻理解和正确实现。一旦这两个方法定义清晰且实现无误，那么Set集合和Stream API的distinct()方法就能非常可靠地完成去重任务。

以上就是《Java集合去重技巧全解析》的详细内容，更多关于的资料请关注golang学习网公众号！