HashSet
add方法调用的map.put()
复习HashMap
在jdk1.8的ConcurrentHashMap也是变成跟HashMap一样的数据结构,所以开始之前先复习一下jdk1.8的HashMap。
HashMap没有任何锁机制,所以线程不安全
HashMap底层维护了Node数组+Node链表+红黑树。
HashMap初始化和扩容只能是2的乘方
HashMap负载因子阈值是数组的0.75
HashMap链表尾插法
HashMap是懒加载机制
HashMap单链表大于8,数组长度大于64变成红黑树提高链表的查找速度。
HashMap无序(根据hash值确定数组位置)不重复(重复就是替换)。
HashMap的key和value允许为null
ConcurrentHashMap和HashMap和Hashtable三者的区别
HashMap:线程不安全
Hashtable:线程安全但是效率低
ConcurrentHashMap:线程安全,相比Hashtable效率高
源码
增加元素
put方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
// hash(key) 扰动函数,将hash值等到后,将hashCode和hashCode右移16位后做亦或操作
// int类型32位,右移后拿高16位和低十六位做亦或操作,起到一个扰乱作用
// 得到的hash值高位不变,低十六位变
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
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;
// table为空的时候,初始化table,懒加载
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// slot没有hash碰撞的时候(slot为null),直接插入到slot中
// 计算数组下标:计算出来的hash值和长度-1做与运算
if ((p = tab[i = (n - 1) & hash]) == null) // p:对应slot中的node:可能为空或者为node,node又可能只有头节点或者形成了链表或者红黑树
// 这里newnode方法,里面是new node对象;new Node<>(hash, key, value, next)
tab[i] = newNode(hash, key, value, null);
else {
// 发生了hash碰撞
Node<K,V> e; K k;
// 判断的头节点的key是否相同,如果相同,则需要覆盖
if (p.hash == hash && // 这里一定相等,为什么要做判断???
((k = p.key) == key || (key != null && key.equals(k)))) // p.key拿的是头节点的key,这里做的是头节点是否一致
e = p; // 将p给了e
// 头节点类型为treenode类型,走红黑树插入
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) { // bincount:链表的个数,不包括头节点
// 0的时候,有两个,7的时候node包括头节点有9个
if ((e = p.next) == null) { // 节点的next为null,说明是尾部,开始插入;插入的情况下,e一定是为null
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st 大于8开始尝试扩容
// 尝试转为红黑树:链表时间复杂度为O(n)
treeifyBin(tab, hash);
break;
}
// 这里是除头节点后判断是否key一致,同上面的覆盖,如果key一致,break;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e; // p等于下一个节点
}
}
// e不为null,说明是非插入,key相同,需要覆盖;此时e指向key相同的那个node
// e不等于null的情况:只有if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))break;这一块代码
// 如果key的hash值在已有元素中没有重复,最后e会为null,只有if ((e = p.next) == null)的时候才会插入,这一块是走不进去的
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value; // e指向key相同的那个node,修改node的value为传进来的value
afterNodeAccess(e); // 钩子方法
return oldValue;
}
}
++modCount; // 修改计数器:增加元素后++,hashmap的size元素个数
if (++size > threshold) // 大于阈值,开始扩容
resize();
afterNodeInsertion(evict); // 钩子方法
return null;
}
treeifyBin方法
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) // 数组长度小于64,继续扩容,不变红黑树
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null; // 用的是treenode
do {
TreeNode<K,V> p = replacementTreeNode(e, null); // 将node替换成treeNode
if (tl == null)
hd = p;
else {
// 将node变为treenode后,再单链表变为双向链表
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
hd.treeify(tab); // 将此节点形成红黑树,这块暂时不看
}
}
resize方法
// 分为初始化扩容和已有长度扩容
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold; // old阈值:一种是构造方法给了值后计算出来的阈值(也会是2的倍数),一种是有了table后,table长度*0.75后得到
int newCap, newThr = 0;
if (oldCap > 0) { // 已有table时,扩容为两倍
if (oldCap >= MAXIMUM_CAPACITY) { // 1 << 30 = 1073741824 小于Integer.MAX_VALUE1 << 31最大值
threshold = Integer.MAX_VALUE;
return oldTab; // 阈值到最大值了,不做扩容直接返回;扩容需要迁移数据,要消耗资源
}
// 新的阈值变为两倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
// table为null时需要初始化table:当new对象调的有参构造方法时,会计算一个阈值,将初始化的table长度设定为阈值
else if (oldThr > 0) // initial capacity was placed in threshold 初始容量大小为阈值
newCap = oldThr;
// table为null时需要初始化table:当调用的是无参构造方法,数组长度给16,阈值给12
else { // zero initial threshold signifies using defaults 零初始阈值表示使用默认值
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// oldcap扩容两倍大于最大容量的情况下:不满足newCap = oldCap << 1) < MAXIMUM_CAPACITY的情况下newThr会==0
// 即最后一次扩容会走这里:扩容<< 1后大于最大阈值
if (newThr == 0) { // 比方说oldCap为1073741823,扩容后为1073741823*2>1073741824MAXIMUM_CAPACITY
float ft = (float)newCap * loadFactor; // 扩容后newcap的阈值
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE); // 一定走后面newThr=Integer.MAX_VALUE
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
// 开始迁移
if (oldTab != null) {
// 循环遍历每个slot
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) { // slot中的node保存在e中
oldTab[j] = null; // slot设置为null,方便GC
if (e.next == null) // 此时只有头节点,没有形成链表,重新计算这个元素的slot
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode) // 红黑树的迁移:暂时不看
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
// loHead,下标不变情况下的链表头
// loTail,下标不变情况下的链表尾
// hiHead,下标改变情况下的链表头
// hiTail,下标改变情况下的链表尾
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
// 以一个链表A->B->C为例
if ((e.hash & oldCap) == 0) { // 只需要计算高一位,下标不变
if (loTail == null)
loHead = e; // 1、把A赋值给loHead
else
// 将满足条件的放到链表尾后面
loTail.next = e; // 4、A.next=B
// 将lotail指向链表尾
loTail = e; // 2、把A赋值给loTail 5、把B赋值给loTail
// 6、 现在新链表是A-->B,然后处理节点C,处理完之后,链表的顺序是A-->B-->C,loHead是A,loTail是C。
// 可以看到,链表中节点顺序和原链表相同
}
else { // 下标变化,下标为n+数组长度
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null); // 3、e=B
// 至此old链表拆分为了两条链表
// 什么时候loTail != null,这里只是加一个健壮性判断?
if (loTail != null) { // 将下标不变的放在原来slot中
loTail.next = null; // 这里为什么要将loTail.next = null???,loTail.next = null一定会为空啊
newTab[j] = loHead;
}
if (hiTail != null) { // 将下标变化的放在j+oldcap中
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}