揭秘Java HashSet：高效去重背后的魔法

原创已于 2025-08-14 17:52:49 修改 · 629 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

于 2025-08-14 17:47:20 首次发布

作为Java集合框架中最常用的Set实现，HashSet以接近O(1)的查询效率和自动去重特性广受欢迎。本文将深入其与HashMap的共生关系，解析设计哲学，并揭示实际开发中的高频陷阱。

一、HashSet的本质：HashMap的“马甲”

核心真相：HashSet 是基于 HashMap 实现的适配器类！查看源码可见：

public class HashSet<E> {
    private transient HashMap<E, Object> map;
    // 虚拟值填充
    private static final Object PRESENT = new Object();
    
    public HashSet() {
        map = new HashMap<>();
    }
    
    public boolean add(E e) {
        return map.put(e, PRESENT) == null; // 元素e作为Key，PRESENT作为固定Value
    }
}

✅ 去重原理：利用HashMap的Key不可重复性
✅ 无序性：继承HashMap的哈希存储特性
✅ 高效查询：复用HashMap的O(1)查询能力

二、核心特性与技术原理

特性	原理说明
元素唯一性	依赖元素的`equals()`和`hashCode()`方法（必须同时重写）
允许null元素	因HashMap支持null键（但只能有一个null值）
非线程安全	与HashMap一致，多线程操作需外部同步
快速失败机制	迭代中修改集合会抛`ConcurrentModificationException`

数据存储示意图：

HashSet: [ "A", "B", null ]
    ↓
内部HashMap：
   Key     | Value
-----------|---------
   "A"     | PRESENT
   "B"     | PRESENT
   null    | PRESENT

三、时间复杂度与性能关键点

操作	时间复杂度	性能影响因素
add()	O(1)	哈希冲突程度、扩容频率
contains()	O(1)	同上（依赖HashMap的get()性能）
remove()	O(1)	同上
iterator遍历	O(n)	桶数量 + 冲突链表/树长度

性能杀手：

未重写hashCode()导致哈希冲突严重
频繁触发扩容（初始容量同HashMap默认16）
冲突链表退化为长链表（Java 8后树化缓解）

四、实战陷阱与规避方案

🚨 陷阱1：未同时重写equals()和hashCode()

class User {
    String id;
    // 错误：只重写equals()未重写hashCode()
    @Override
    public boolean equals(Object o) { /* 根据id比较 */ }
}

Set<User> users = new HashSet<>();
users.add(new User("1001"));
users.contains(new User("1001")); // 返回false！违反直觉

修复方案：遵守契约同时重写两方法

@Override
public int hashCode() {
    return Objects.hash(id); // 保证相同id的对象哈希值相同
}

🚨 陷阱2：依赖可变对象作元素

Set<StringBuilder> set = new HashSet<>();
StringBuilder sb = new StringBuilder("A");
set.add(sb);

sb.append("B");  // 修改已存在元素
System.out.println(set.contains(sb)); // true（还在原桶位）
System.out.println(set.contains(new StringBuilder("A"))); // false
System.out.println(set.contains(new StringBuilder("AB"))); // false ❗

原因：修改后：

hashCode()改变 → 新位置无数据
但原桶位仍存储旧引用（内存泄漏风险）

最佳实践：
✅ 优先使用String、Integer等不可变对象作为元素
✅ 如需可变对象，确保修改时不移除或重哈希

🚨 陷阱3：误用自定义对象去重

// 错误示例：希望根据订单金额去重
Set<Order> orders = new HashSet<>();
orders.add(new Order(100.0)); 
orders.add(new Order(100.0)); // 被错误保留

class Order {
    double amount;
    // 未重写equals/hashCode → 默认使用对象地址比较！
}

解决方案：明确业务去重逻辑

@Override
public int hashCode() {
    return Double.hashCode(amount); // 按金额去重
}

@Override
public boolean equals(Object o) {
    return Double.compare(amount, ((Order)o).amount) == 0;
}

五、三大Set实现类横向对比

特性	HashSet	LinkedHashSet	TreeSet
底层实现	HashMap	LinkedHashMap	红黑树
排序保证	❌ 无序	✅ 插入顺序	✅ 自然顺序/Comparator
查/增/删性能	O(1)	O(1)	O(log n)
允许null元素	✅	✅	❌（除非自定义比较器）
内存开销	最低	较高（维护双向链表）	较高（树结构）
适用场景	通用去重	需保留插入顺序的去重	需排序的去重集合

六、进阶使用技巧

初始化优化

// 预期存放1000元素，避免扩容
Set<String> set = new HashSet<>(1333); // 1333 ≈ 1000/0.75

并行流安全去重

List<String> data = Arrays.asList("A", "B", "A");
Set<String> unique = data.parallelStream()
                          .collect(Collectors.toConcurrentHashSet());

深度拷贝方案

// 浅拷贝（元素引用共享）
Set<User> copy1 = new HashSet<>(originalSet);

// 深拷贝方案（需元素实现Cloneable）
Set<User> copy2 = originalSet.stream()
                             .map(User::clone)
                             .collect(Collectors.toSet());

七、与HashMap的性能联动

操作	HashSet影响	内部HashMap状态变化
add(e)	桶位空 → 直接插入	新增<e, PRESENT>键值对
add(已存在e)	返回false	put(e, PRESENT)返回旧PRESENT值
扩容时	性能骤降	rehash所有键值对
树化时	链表查询变慢，插入删除稳定	桶内链表→红黑树转换