如何在Java中使用HashSet存储唯一元素_技术教程

HashSet通过哈希表实现元素唯一性，添加元素时自动去重，适用于快速查找、去重及集合操作，但需重写自定义类的hashCode与equals方法以确保正确性。

Java中要存储唯一元素，

HashSet

无疑是首选，它通过其内部的哈希机制确保了集合中不会出现重复项。你只需要将元素添加到

HashSet

中，它就会自动处理去重逻辑。

解决方案

HashSet

是Java集合框架中

Set

接口的一个实现，它底层基于哈希表（

HashMap

）实现。当你向

HashSet

中添加一个元素时，它会先计算该元素的哈希码（

hashCode()

方法），然后根据哈希码找到存储位置。接着，它会检查该位置是否已经存在一个与新元素“相等”（

equals()

方法）的元素

。如果存在，新元素就不会被添加进来；如果不存在，新元素才会被成功加入。这个过程是自动且高效的。

这里有个简单的例子，展示了

HashSet

如何工作：

import java.util.HashSet;
import java.util.Set;

public class UniqueElementsExample {
    public static void main(String[] args) {
        Set uniqueNames = new HashSet<>();

        System.out.println("尝试添加元素...");
        // 添加一些字符串
        System.out.println("添加 'Alice': " + uniqueNames.add("Alice")); // 第一次添加，通常返回true
        System.out.println("添加 'Bob': " + uniqueNames.add("Bob"));
        System.out.println("添加 'Alice' (重复): " + uniqueNames.add("Alice")); // 重复添加，返回false
        System.out.println("添加 'Charlie': " + uniqueNames.add("Charlie"));
        System.out.println("添加 'Bob' (重复): " + uniqueNames.add("Bob")); // 重复添加，返回false

        System.out.println("\nHashSet中的唯一元素:");
        for (String name : uniqueNames) {
            System.out.println(name);
        }

        System.out.println("\nHashSet的大小: " + uniqueNames.size()); // 预期大小为3
    }
}

运行这段代码，你会发现输出结果中“Alice”和“Bob”只出现了一次，

HashSet

的大小也是3，而不是5。这正是

HashSet

的魅力所在，它在后台默默地为你处理了元素的唯一性。

自定义对象在HashSet中如何保证唯一性？

对于像

String

、

Integer

这类Java内置类型，它们已经正确地重写了

hashCode()

和

equals()

方法，所以直接放入

HashSet

就能保证唯一性。但当我们处理自定义对象时，情况就有些不同了。如果你直接将自定义对象放入

HashSet

，很可能会发现即使内容完全相同的两个对象也被视为不同的元素，因为

Object

类默认的

hashCode()

和

equals()

方法是基于对象的内存地址来判断的。

要让

HashSet

正确识别自定义对象的唯一性，你必须在自定义类中重写

hashCode()

和

equals()

方法。这是Java中一个非常重要的契约：如果两个对象

equals()

true

，那么它们的

hashCode()

值必须相同。反之，如果

hashCode()

值相同，

equals()

不一定返回

true

（这会导致哈希冲突，但仍能通过

equals

判断唯一性）。

举个例子，假设我们有一个

Person

类：

class Person {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

    // 默认情况下，HashSet会认为两个内容相同的Person对象是不同的
    // 因为它们在内存中的地址不同。
    // 必须重写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() {
        // 通常使用Objects.hash()来生成哈希码，它会综合考虑所有参与equals比较的字段
        return java.util.Objects.hash(name, age);
    }
}

在上面的

Person

类中，我们重写了

equals()

和

hashCode()

。

equals()

方法现在会比较

name

和

age

字段是否相同，而

hashCode()

则会基于这两个字段生成一个哈希码。这样，当

HashSet

处理

Person

对象时，它就能正确地判断两个

Person

对象是否“相等”，从而保证了集合中

Person

对象的唯一性。

如果你忘记重写或者重写不当，比如只重写了

equals()

而没有重写

hashCode()

，那么程序在运行时可能会出现意想不到的行为，甚至导致

HashSet

无法正常工作，因为哈希码的冲突处理机制会失效。所以，这两个方法总是应该一起重写，并且遵循它们之间的契约。

HashSet的性能特点和适用场景是什么？

HashSet

以其出色的性能，在许多场景下都表现得游刃有余。它的核心优势在于查找、添加和删除操作的平均时间复杂度都是O(1)。这意味着无论集合中有多少元素，这些操作的耗时理论上都是常数级别的，非常快。当然，这是在没有大量哈希冲突的理想情况下。如果哈希函数设计不佳导致大量冲突，最坏情况下性能可能会退化到O(n)。

性能特点：

快速查找、添加、删除： 平均O(1)时间复杂度，这得益于哈希表的数据结构。
无序性：
```
HashSet
```
不保证元素的存储顺序，你不能指望迭代时元素会按照添加的顺序或者任何特定顺序出现。
非线程安全：
```
HashSet
```
不是线程安全的。在多线程环境下，如果多个线程同时修改
```
HashSet
```
，可能会导致数据不一致或运行时错误。如果需要线程安全，可以使用
```
Collections.synchronizedSet(new HashSet<>())
```
或
```
java.util.concurrent.ConcurrentHashMap
```
的键集（
```
keySet()
```
）。
空间换时间： 为了实现O(1)的平均时间复杂度，
```
HashSet
```
通常会占用比
```
ArrayList
```
更多的内存空间，因为它需要存储哈希表结构以及可能存在的空槽。

适用场景：

去重： 这是

HashSet

最典型的应用。当你有一个包含重复元素的列表，想快速得到一个只包含唯一元素的新列表时，

HashSet

是最佳选择。

List rawList = Arrays.asList("apple", "banana", "apple", "orange", "banana");
Set uniqueItems = new HashSet<>(rawList); // 快速去重
System.out.println(uniqueItems); // 输出: [orange, banana, apple] (顺序不确定)

快速判断元素是否存在： 如果你需要频繁地检查某个元素是否在集合中，

HashSet

的

contains()

方法效率极高。

Set dictionary = new HashSet<>(Arrays.asList("cat", "dog", "bird"));
boolean found = dictionary.contains("dog"); // O(1)查找

实现缓存： 比如，记录已经处理过的ID，避免重复处理。
数学集合操作： 比如计算两个集合的交集、并集、差集，
```
HashSet
```
提供了便捷的方法（如
```
retainAll()
```
,
```
addAll()
```
,
```
removeAll()
```
）。