JDK 8 HashSet 源码详解（完整版带详细注释）
1. 基本结构和常量定义
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.Serializable {
// 序列化版本号
static final long serialVersionUID = -5024744406713321676L;
// 底层使用HashMap存储元素，key为HashSet的元素，value为PRESENT对象
private transient HashMap<E,Object> map;
// HashMap中value的占位符对象，所有元素都使用这个相同的值
private static final Object PRESENT = new Object();
}
2. 构造函数
/**
* 无参构造函数
* 构造一个空的HashSet，默认初始容量为16，负载因子为0.75
*/
public HashSet() {
map = new HashMap<>();
}
/**
* 指定初始容量的构造函数
* @param initialCapacity 初始容量
*/
public HashSet(int initialCapacity) {
map = new HashMap<>(initialCapacity);
}
/**
* 指定初始容量和负载因子的构造函数
* @param initialCapacity 初始容量
* @param loadFactor 负载因子
*/
public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<>(initialCapacity, loadFactor);
}
/**
* 从集合构造HashSet
* @param c 要构造HashSet的集合
* @throws NullPointerException 如果集合为null
*/
public HashSet(Collection<? extends E> c) {
map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
addAll(c);
}
/**
* 内部构造函数，用于LinkedHashSet
* @param initialCapacity 初始容量
* @param loadFactor 负载因子
* @param dummy 无意义参数，用于区分构造函数
*/
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
map = new LinkedHashMap<>(initialCapacity, loadFactor);
}
3. 核心方法实现
3.1 add方法
/**
* 添加元素到HashSet中
* @param e 要添加的元素
* @return 如果元素不存在则添加并返回true，如果元素已存在则返回false
*/
public boolean add(E e) {
// 调用HashMap的put方法，value始终为PRESENT对象
// 如果返回null说明是新添加的元素，否则说明元素已存在
return map.put(e, PRESENT) == null;
}
3.2 remove方法
/**
* 从HashSet中移除指定元素
* @param o 要移除的元素
* @return 如果元素存在并被移除返回true，否则返回false
*/
public boolean remove(Object o) {
// 调用HashMap的remove方法，如果返回PRESENT说明元素存在并被移除
return map.remove(o) == PRESENT;
}
3.3 contains方法
/**
* 判断HashSet是否包含指定元素
* @param o 要查找的元素
* @return 如果包含返回true，否则返回false
*/
public boolean contains(Object o) {
// 调用HashMap的containsKey方法
return map.containsKey(o);
}
3.4 size和isEmpty方法
/**
* 返回HashSet中元素的数量
*/
public int size() {
return map.size();
}
/**
* 判断HashSet是否为空
*/
public boolean isEmpty() {
return map.isEmpty();
}
3.5 clear方法
/**
* 清空HashSet中的所有元素
*/
public void clear() {
map.clear();
}
4. 迭代器实现
/**
* 返回迭代器
*/
public Iterator<E> iterator() {
// 返回HashMap的keySet的迭代器
return map.keySet().iterator();
}
5. 其他重要方法
5.1 toArray方法
/**
* 返回包含所有元素的数组
*/
public Object[] toArray() {
return map.keySet().toArray();
}
/**
* 返回包含所有元素的指定类型数组
*/
public <T> T[] toArray(T[] a) {
return map.keySet().toArray(a);
}
5.2 clone方法
/**
* 克隆方法
*/
@SuppressWarnings("unchecked")
public Object clone() {
try {
HashSet<E> newSet = (HashSet<E>) super.clone();
newSet.map = (HashMap<E, Object>) map.clone();
return newSet;
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
}
5.3 序列化相关方法
/**
* 序列化写入方法
*/
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// 写入默认的序列化信息
s.defaultWriteObject();
// 写入HashMap的容量和负载因子
s.writeInt(map.capacity());
s.writeFloat(map.loadFactor());
// 写入元素数量
s.writeInt(map.size());
// 依次写入每个元素
for (E e : map.keySet())
s.writeObject(e);
}
/**
* 序列化读取方法
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// 读取默认的序列化信息
s.defaultReadObject();
// 读取HashMap的容量和负载因子
int capacity = s.readInt();
if (capacity < 0) {
throw new InvalidObjectException("Illegal capacity: " +
capacity);
}
float loadFactor = s.readFloat();
if (loadFactor <= 0 || Float.isNaN(loadFactor)) {
throw new InvalidObjectException("Illegal load factor: " +
loadFactor);
}
// 读取元素数量
int size = s.readInt();
if (size < 0) {
throw new InvalidObjectException("Illegal size: " +
size);
}
// 创建HashMap
map = (((HashSet)this) instanceof LinkedHashSet ?
new LinkedHashMap<E,Object>(capacity, loadFactor) :
new HashMap<E,Object>(capacity, loadFactor));
// 读取并添加元素
for (int i=0; i<size; i++) {
@SuppressWarnings("unchecked")
E e = (E) s.readObject();
map.put(e, PRESENT);
}
}
5.4 Spliterator方法（Java 8新增）
/**
* 返回Spliterator（用于并行流操作）
*/
public Spliterator<E> spliterator() {
return map.keySet().spliterator();
}
6. LinkedHashSet的实现
/**
* LinkedHashSet是HashSet的子类，保持插入顺序
*/
public class LinkedHashSet<E>
extends HashSet<E>
implements Set<E>, Cloneable, java.io.Serializable {
private static final long serialVersionUID = -2851667679971038690L;
/**
* 无参构造函数
*/
public LinkedHashSet() {
super(16, .75f, true);
}
/**
* 指定初始容量的构造函数
*/
public LinkedHashSet(int initialCapacity) {
super(initialCapacity, .75f, true);
}
/**
* 指定初始容量和负载因子的构造函数
*/
public LinkedHashSet(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor, true);
}
/**
* 从集合构造LinkedHashSet
*/
public LinkedHashSet(Collection<? extends E> c) {
super(Math.max(2*c.size(), 11), .75f, true);
addAll(c);
}
}
7. 总结
7.1 HashSet的特点
- 底层实现：基于HashMap实现，元素作为HashMap的key存储
- 无序性：不保证元素的插入顺序（LinkedHashSet保持插入顺序）
- 唯一性：不允许存储重复元素
- 允许null：可以存储一个null元素
- 非线程安全：不是线程安全的
- 高性能：基本操作（add、remove、contains）平均时间复杂度为O(1)
7.2 时间复杂度分析
- 添加元素：O(1) 平均情况，O(n) 最坏情况（哈希冲突严重时）
- 删除元素：O(1) 平均情况，O(n) 最坏情况
- 查找元素：O(1) 平均情况，O(n) 最坏情况
- 遍历元素：O(n) - 需要遍历所有元素
7.3 空间复杂度
- 存储空间：O(n) - n为存储的元素个数
- 额外空间：HashMap需要额外的存储空间（哈希表、链表/红黑树等）
7.4 HashSet与HashMap的关系
// HashSet内部结构示意图：
// HashSet中的元素e <--> HashMap中的键值对(e, PRESENT)
// 其中PRESENT是一个共享的Object实例
7.5 使用建议
-
适用场景：
- 需要去除重复元素
- 需要快速查找元素是否存在
- 不关心元素的顺序
- 需要高性能的集合操作
-
不适用场景：
- 需要保持元素的插入顺序（考虑使用LinkedHashSet）
- 需要对元素进行排序（考虑使用TreeSet）
- 多线程环境（考虑使用Collections.synchronizedSet()包装）
-
性能优化：
- 如果能预估元素数量，使用带初始容量的构造函数
- 选择合适的负载因子（默认0.75是时间和空间的平衡点）
- 确保元素的hashCode()和equals()方法正确实现
7.6 关键设计思想
- 委托模式：HashSet将大部分操作委托给内部的HashMap实现
- 占位符模式：使用固定的PRESENT对象作为HashMap的value
- 适配器模式：将Map接口适配为Set接口
- 继承复用：LinkedHashSet通过继承HashSet复用大部分代码
HashSet的设计体现了面向对象设计的精髓：简单、高效、易于理解和维护。通过组合HashMap，HashSet获得了优秀的性能表现，同时保持了代码的简洁性。
扫一扫
5385
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
