阅读源码的时候,就会像在拔一棵树,带着各种根茎的大树,需要一点点的把根茎梳理清楚。那种抽丝剥茧的快乐(是快乐么?),难以言喻
而且仅仅只是HashMap的源码,就已经让人头秃了。
本篇博文的版本是基于java8的。
1.首先快乐的建立了一下测试代码
public class HashMapTest {
public static void main(String[] args) {
HashMap<String, Object> hashMap = new HashMap<>();
hashMap.put("1", "1");
}
}
然后断点进入到new HashMap()方法。
原来就是一行赋值操作负载因子而已。就是把一个变量赋值成某一个静态变量。但其实这里面大有讲究。讲究到我得专门再写一篇文章。好的。 请移步到下面那篇文档读一读概念。
好的。我们明白了他设置了一个负载因子,备用。
2.接下来呢,进入put方法
那么put方法又做了啥惊人的操作,好的,第一个参数,hash( key) 方法。
那么我们都知道Object类是所有java类的父类,那么Object类中的hashCode方法,是个什么鬼呢,他的底层实现方法是什么呢,怎么计算hashCode的呢。那我们接着看。HashMap底层原理的故事-Object的hashCode
1.计算hashCode的时候,为什么要无符号右移16位后做异或运算
根据上面的说明我们做一个简单演练
将h无符号右移16为相当于将高区16位移动到了低区的16位,再与原hashcode做异或运算,可以将高低位二进制特征混合起来
从上文可知高区的16位与原hashcode相比没有发生变化,低区的16位发生了变化
我们可知通过上面(h = key.hashCode()) ^ (h >>> 16)进行运算可以把高区与低区的二进制特征混合到低区,那么为什么要这么做呢?
我们都知道重新计算出的新哈希值在后面将会参与hashmap中数组槽位的计算,计算公式:(n - 1) & hash,假如这时数组槽位有16个,则槽位计算如下:
仔细观察上文不难发现,高区的16位很有可能会被数组槽位数的二进制码锁屏蔽,如果我们不做刚才移位异或运算,那么在计算槽位时将丢失高区特征
也许你可能会说,即使丢失了高区特征不同hashcode也可以计算出不同的槽位来,但是细想当两个哈希码很接近时,那么这高区的一点点差异就可能导致一次哈希碰撞,所以这也是将性能做到极致的一种体现
2.使用异或运算的原因
异或运算能更好的保留各部分的特征,如果采用&运算计算出来的值会向1靠拢,采用|运算计算出来的值会向0靠拢
3.为什么槽位数必须使用2^n
如果槽位数是2的N次方,那么可以通过位运算e.hash & (newCap - 1)来计算,也就是说a % (2^n) 等价于 a & (2^n - 1) ,位运算的运算效率高于算术运算,原因是算术运算还是会被转化为位运算
不懂 槽位是啥,没关系,带着疑问往下看,慢慢就明白了。
2.接下来,跟踪的是putVal方法
先解释一下Node是啥:
put第一个元素的流程
红色的代码表示执行过程。后面有文字分析
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i; 都是空的
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length; //resize()里面干了啥,咱们移步到这里resize()方法详解 最终n=16, tab=长度为16的数组new Node[16]
if ((p = tab[i = (n - 1) & hash]) == null) // 来了,根据key的hash值对16取余,然后看下这个key值落在哪个槽位里。这个最终结果i=1,p=null;这就是槽位的概念的产生。以及为什么槽位非得要2的N次方,因为只有这样a % (2^n) 等价于 a & (2^n - 1)。然后看下这个槽位是不是空的。
tab[i] = newNode(hash, key, value, null); // 是空的,就新建个节点插入进去
else {
Node<K,V> e; K k;
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) // -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;// 全局变量modCount,变动次数加1,最终值为1
if (++size > threshold)//这个意思是啥呢。全局变量size从0变成1, threshold之前的resize()之后他现在是12,参考resize()方法详解 他最终会把全局变量threshold=12, 1<12,当然不扩容。 这里就有了个重要结论:当hashMap添加完元素后,如果发现size值>threshold (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY HashMap底层原理的故事-负载因子和初始容量)时,他就会扩容。扩容多少呢。我们下面讲哈。
resize();
afterNodeInsertion(evict);
return null;
}
第一次put结束后,全局变量的最终态。
threshold | 12 |
table | 长度为16的数组new Node[16] , Node[1]=newNode("1".hash, "1", "1", null) |
size | 1 |
modCount | 1 |
put第二个元素的流程(跟第一个元素在同一个槽位上)
我们第一次put : hashMap.put("1", "1");
于是我们进行第二次put: 通过计算我们得知 如果key="12",他会跟key="1"放在同一个槽位上。
所以我们的测试代码为:
HashMap<String, Object> hashMap = new HashMap<>();
hashMap.put("1", "1");
hashMap.put("12", "12");
并且我们现在分析第二个元素的流程,还是令人熟悉的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;//当然了,还是空的
if ((tab = table) == null || (n = tab.length) == 0);//这次就不一样了。咱们的全局变量table是有值的,它是长度为16的数组new Node[16] , Node[1]=newNode("1".hash, "1", "1", null)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null) // 这下一经计算,槽位是同一个i=1。因为之前i=1已经放了一个key="1"的元素了,p=(key=“1”的node)所以这个判断是false;
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) //判断下是不是put了key值相同的元素,决定是否要覆盖原有值,当然,这里不是哈。这里就有了个重要结论:判断key值重复的方法其实是key的equals方法
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); 就是把key=“1”的节点的next指向key=“12”的节点
if (binCount >= TREEIFY_THRESHOLD - 1) // TREEIFY_THRESHOLD=8看下不够8
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; //全局变量+1=2
if (++size > threshold)
resize();
afterNodeInsertion(evict); 这个是干啥呢hashMap里面是啥都没干哈。不用看了。。
return null;
}
put第三-七个元素的流程(跟第一二个元素在同一个槽位上)
HashMap<String, Object> hashMap = new HashMap<>();
hashMap.put("1", "1");
hashMap.put("12", "12");
hashMap.put("23", "23");
核心 代码就一句p = e; 不停的变换指针找到tab[1]上面的所有链表的最末端,然后挂上去。直到---第8个元素
put第八个元素的流程(跟前7个元素在同一个槽位上)
当同一个槽位上的链表长度达到8的时候,
终于进入到了令人振奋的环节。转变为红黑树 什么是红黑树?之后我再开个章节写下
treeifyBin(tab, hash);
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) // 16小于64,还不够格,接着给我扩容去
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
do {
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}