java源码阅读----jdk1.8 HashMAP
一、创建对象
-
创建一个HashMap的对象
-
跟踪进去,可以看到进入无参构造方法,该方法里,给加载因子LoadFactor赋值0.75
二、 添加对象
-
在测试代码里使用put方法,放入一个键值对
-
进入put方法里面。调用了putVal方法,putVal方法的第一个参数传入的是使用hash方法求得的key的哈希值。
-
进入hash方法。可以看见如果key是null,则返回0,否则的话计算key的hashCode,并且对求得的hash值进行低16位与高16位的异或操作。为什么这样做呢?一种解释是,因为我们在求一个元素对应下标的时候是index=hash & table.length-1。一般情况下hash值的高位是用不到的,这样会增加冲突的概率。为了降低冲突的概率,就把高16位也给使用上。
- 进入putVal方法。传入的参数是 hash(key), key, value, false, true
/*
参数1:键的hash值
参数2:键
参数3:值
参数4:false 表示覆盖已经存在的值,因为map不允许有重复的key,如果重复了以新加入的为准
参数5:true 不重新创建table,应该与扩容有关
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//定义了一个临时数组
Node<K,V>[] tab;
//一个结点
Node<K,V> p;
// n是数组长度,i是下标
int n, i;
/*
tab = table
如果table为空,或者长度0
那么使用resize()给table分配空间,转第5部分
*/
if ((tab = table) == null || (n = tab.length) == 0){
n = (tab = resize()).length;
}
/*
i= (n-1) & hash 计算元素应该放在哪个数组的哪个位置
看这位置上是不是已经有值了,如果没有值,就把键值对放在这个位置上
*/
if ((p = tab[i = (n - 1) & hash]) == null){
tab[i] = newNode(hash, key, value, null);
}//如果这个位置已经有值了,
else {
Node<K,V> e; K k;
//table[i]的第一个节点是不是和新加入的结点的key是不是一样
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k)))){
//记录table[i]的第一个结点
e = p;
}
//如果table[i]的第一个结点是不是树结点
else if (p instanceof TreeNode){
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
}
//如果不是与第一个重复的结点,且不是树结点
else {
//binCount是统计当前的i位置下链接的结点个数。
for (int binCount = 0; ; ++binCount) {
//一直找到最后的结点,把新结点链接到最后
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//如果达到阈值减1 = 7 就进行树化, 进入第6部分查看treeifyBin方法
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;
}
}
// 如果e不是空的,说明存在重复的
if (e != null) { // existing mapping for key
V oldValue = e.value;
//进行替换
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//如果达到阈值,进行扩容
if (++size > threshold)
resize();
//把新的映射关系添加到某个Node的后面
afterNodeInsertion(evict);
return null;
}
- resize方法,如果是第一次put,那么table就是空的,那么就创建一个长度为16的数组,阈值为12.
final Node<K,V>[] resize() {
//oldTable 记录一下原来的table
Node<K,V>[] oldTab = table;
//oldCap 记录原来数组的长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//oldThr 记录原先的阈值,默认为0
int oldThr = threshold;
//设置新的容量和阈值
int newCap, newThr = 0;
//如果原来的table 不为空
if (oldCap > 0) {
//如果 原先的数组容量大于最大容量,那么就将阈值设为最大,直接返回旧的table
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//扩容2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//阈值也要扩容2倍
newThr = oldThr << 1; // double threshold
}//如果原来的table为空,且原先的阈值大于0
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else //如果原来的table为空,且原先的阈值不大于0
{ // zero initial threshold signifies using defaults
//设置数组的默认初始容量 16
newCap = DEFAULT_INITIAL_CAPACITY;
//设置数组默认的阈值大小 16*0.75 = 12
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//如果新的阈值为0
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//将阈值 设置为新阈值
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
//创建一个新的table数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
//如果原来的数组不为空
if (oldTab != null) {
//把原来table中的映射关系,放入新的table中
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)
//把原来的树拆解,并重新计算hash,重新放
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
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;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
- treeifyBin
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
//如果table是空的,或者table数组的长度没有达到最小树化容量,就先扩容
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
//用e记录table[index]的结点地址
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);
}
}
总结:
- 如果是第一次添加:把table初始化长度为16的数组,threshold为12
- 如果不是第一次添加:
- 考虑Key是否有重复,如果有重复,那么就替换value
- 如果不重复,判断table[i]下面链接的是不是一个树
- 若不是树,统计table[i]下面链接了多少个结点,如果达到了7个就要考虑树化。
- 如果达到7个,但是table的长度没有达到64,那么先扩容
- 如果达到7个,且table的长度达到64,直接树化
- 若不是树,统计table[i]下面链接了多少个结点,如果达到了7个就要考虑树化。
- table[i]下面已经是树,单独处理,直接把新的映射关系链接到树的叶子结点
- 添加后如果size达到阈值,则还要扩容,一旦扩容这要重新放所有的映射。