public boolean add(E e) 源码分析
源码的角度分析：
1、HashSet 底层是HashMap
2、添加一个元素时，先通过该元素的hashCode方法得到哈希值，对哈希值进行运算得到索引值
3、找到存储数据表的table，看这个索引位置是否已经存放有其他元素
4、如果没有，直接加入
5、如果有，调用equals方法对 key 进行内容比较，
-
如果相同，就放弃添加
-
如果不同，则尾插方式添加到最后
6、在JVAVA8中，如果一条链表的元素个数超过8，并且table【存储数据表】>= 64就会进行树化（转红黑树
public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, java.io.Serializable {
// 底层是HashMap
private transient HashMap<E,Object> map;
// 节点value是一个object对象
private static final Object PRESENT = new Object();
// 添加方法
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
// 调用HashMap的putVal方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* hash【数组索引下标】: 元素通过调用hashCode方法获取hashCode值【高位】，
* 然后hashCode值无符号右移16位【低位】，再异或上hashCode值,得到hash真正的数组下标
* 这个操作的目的是将哈希码的高位和低位进行混合，以减少哈希冲突的可能性
*/
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
/**
*
* 1、如果定位到的数组位置没有元素 就直接插入。
2、如果定位到的数组位置有元素就和要插入的 key 比较，如果 key 相同就直接覆盖，如果 key 不相同，就判断 p 是否是一个树节点，
如果是就调用e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value)将元素添加进入。如果不是就遍历链表插入(插入的是链表尾部)
*
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i; // 定义的辅助变量
// table是HashMap的数组， Node<K,V>[] table;
// if 语句表示如果当前table 是null, 或者 大小=0
// 就是第一次扩容，到16个空间
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 通过(n - 1) & hash获取数组下标,再通过下标获取节点 p，并判断节点是否为空
// 并把这个位置的对象，赋给 p
// (2)判断p 是否为null
// (2.1) 如果p 为null, 表示还没有存放元素, 就创建一个 new Node (key="java",value=PRESENT)
// (2.2) 就放在该位置 tab[i] = newNode(hash, key, value, null)
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
// 数组中该下标对应的节点已经存在（处理hash冲突）
else {
Node<K,V> e; K k;
// 判断当前索引位置对应的链表的第一个元素和准备添加的key的hash值是否一样 ？
// 当满足以下两个条件之一时，添加失败，不能加入:
// (1) 准备加入的key 和 p 指向的Node 结点的 key 是同一个对象
// (2) p 指向的Node 结点的 key 的equals() 和准备加入的key比较后相同
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 判断 p 是不是红黑树的一个节点对象
// 如果是一颗红黑树，就调用 putTreeVal , 来进行添加
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 不是红黑树节点则说明为链表结点
else {
// 如果table对应索引位置，已经是一个链表, 就使用for循环比较
// (1) 依次和该链表的每一个元素比较后，都不相同, 则加入到该链表的最后
// 注意在把元素添加到链表后，立即判断 该链表是否已经达到8个结点, 就调用 treeifyBin() 对当前这个链表进行树化(转成红黑树)
// 注意，在转成红黑树时，要进行判断, 判断条件
// if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY(64))
// resize();
// 如果上面条件成立，先table扩容.
// 只有上面条件不成立时，才进行转成红黑树
// (2) 依次和该链表的每一个元素比较过程中，如果有相同情况,就直接break
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
// 如果一条链表的元素个数到达TREEIFY_THRESHOLD(默认是8),
// 并且table的大小>=MIN_TREEIFY_CAPACITY(默认是64),链表会进行树化
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
//用新值替换旧值
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount; // 记录该集合修改次数
//size 就是我们每加入一个结点Node(k,v,h,next), size++
// 实际大小大于阈值则扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
}
对 putVal 方法进行图形分析：
resize 方法:
进行扩容，会伴随着一次重新 hash 分配，并且会遍历 hash 表中所有的元素，是非常耗时的。在编写程序中，
要尽量避免 resize。resize 方法实际上是将 table 初始化 和 table 扩容 进行了整合，底层的行为都是给 table 赋值一个新的数组。
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
// 超过最大值就不再扩充了，就只好随你碰撞去吧
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 没超过最大值，就扩充为原来的2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
// 创建对象时初始化容量大小放在threshold中，此时只需要将其作为新的数组容量
newCap = oldThr;
else {
// signifies using defaults 无参构造函数创建的对象在这里计算容量和阈值
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
// 创建时指定了初始化容量或者负载因子，在这里进行阈值初始化，
// 或者扩容前的旧容量小于16，在这里计算新的resize上限
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
// 这里采用高低映射的方式进行对新数组的映射
if (oldTab != null) {
// 遍历旧数组复制到新数组中
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
// 如果当前节点链表只有一个节点，则直接赋值
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
// 将红黑树拆分成2棵子树，如果子树节点数小于等于 UNTREEIFY_THRESHOLD（默认为 6），则将子树转换为链表。
// 如果子树节点数大于 UNTREEIFY_THRESHOLD，则保持子树的树结构。
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else {
// 链链表赋值，高低映射
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
// 判断原索引 和 扩容后索引是否相同，若相同，则将原索引数据放入到低位链表中
if ((e.hash & oldCap) == 0) {
// 相同则低位链表尾插
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
// 否则高位链表尾插
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
// 如果低位不为空，则说明链表有数据，则采用尾插的方式，将数据添加到节点尾部
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
// 高位链，直接将旧数据放到 原索引 + oldCap的哈希槽中
// 因为是2倍扩容，扩容后位置是原位置 + 增长的长度
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
一、JDK 1.8 中 HashSet 的 add 方法源码详细分析
在 JDK 1.8 中，HashSet 是基于 HashMap 实现的，HashSet 的 add 方法的核心逻辑依赖于 HashMap 的 put 方法。下面我们将从 HashSet 的 add 方法入手，逐步分析其源码实现
二、HashSet 的 add 方法
HashSet 的 add 方法用于向集合中添加元素。
如果元素已存在，则不会添加并返回 false；
如果元素不存在，则添加并返回 true。它的源码如下：
参数说明
-
e：要添加的元素。
-
PRESENT：一个固定的 Object 对象，作为 HashMap 的值（value）
返回值
-
如果元素 e 不存在，map.put(e, PRESENT) 返回 null，表示添加成功
-
如果元素 e 已存在，map.put(e, PRESENT) 返回 PRESENT，表示添加失败
三、HashSet 的内部实现
HashSet 的内部是基于 HashMap 实现的。HashSet 的元素作为 HashMap 的键（key），而值（value）是一个固定的 PRESENT 对象（private static final Object PRESENT = new Object()）
HashSet 的构造函数
HashSet 的构造函数会初始化内部的 HashMap。例如：
PRESENT 对象
PRESENT 是一个静态常量，用于作为 HashMap 的值：
四、HashMap 的 put 方法
HashSet 的 add 方法依赖于 HashMap 的 put 方法。以下是 HashMap 的 put 方法的源码（JDK 1.8）：
hash(key) 方法
hash(key) 方法用于计算键的哈希值：
-
如果键为 null，返回 0。
-
否则，返回键的哈希码与高 16 位的异或结果（目的是减少哈希冲突）
五、putVal 方法
putVal 方法是 HashMap 的核心方法，用于将键值对插入哈希表中。以下是 putVal 方法的源码：
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
Node<K,V>[] tab; // 哈希表数组
Node<K,V> p; // 当前节点
int n, i; // n: 哈希表长度; i: 索引位置
// 如果哈希表为空或长度为 0，进行扩容
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 计算索引位置，如果该位置为空，直接插入新节点
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; // 目标节点
K k; // 当前节点的键
// 检查第一个节点是否匹配
// 如果已存在的key和传入的key一模一样，则需要覆盖
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 如果节点是树节点，调用红黑树的插入方法
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 遍历链表
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
// 插入新节点
p.next = newNode(hash, key, value, null);
// 如果链表长度超过阈值，转换为红黑树
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
break;
}
// 检查节点是否匹配
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 如果找到匹配的节点，更新值并返回旧值
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
// 修改计数器加 1
++modCount;
// 如果元素数量超过阈值，进行扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
六、源码解析
1、初始化哈希表：
- 如果哈希表为空或长度为 0，调用 resize() 方法进行扩容
2、计算索引位置：
-
使用 (n - 1) & hash 计算键的存储位置。
-
如果该位置为空，直接插入新节点
3、处理哈希冲突：
-
如果该位置不为空，检查第一个节点是否匹配。
-
如果节点是树节点，调用红黑树的插入方法。
-
否则，遍历链表，插入新节点或更新值。
4、更新值：
- 如果找到匹配的节点，更新值并返回旧值
5、扩容：
- 如果元素数量超过阈值，调用 resize() 方法进行扩容。
七、总结
HashSet 的 add 方法通过调用内部 HashMap 的 put 方法实现元素的添加。它的核心逻辑是：
-
如果元素不存在，添加到 HashMap 中并返回 true。
-
如果元素已存在，返回 false。
在 JDK 1.8 中，HashMap 的实现引入了红黑树优化，当链表长度超过阈值时，链表会转换为红黑树，以提高查找性能。
HashSet 的 add 方法的时间复杂度为 O(1)，适合需要快速查找和去重的场景。在使用时，注意重写 equals() 和 hashCode() 方法，并根据需求选择合适的初始容量和负载因子。
浙公网安备 33010602011771号