HashMap保存键值对数据的步骤总结
文章目录
HashMap的put方法流程图
HashMap的存值过程
①put()方法中调用了putVal()方法,在调用putVal前,使用HashMap的hash()方法,获取key的一个新的哈希值。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
次方法中,获取key的hash值
^
key高16为的哈希值
目的是为了在之后计算存放数组的位置时,key的哈希值充分运算,会降低冲突
②putVal()方法,先判断当前数组是否为null或数组长度为0。
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;
如果数组长度为null或为0,调用resize()方法,进行数组扩容,参考hashMap的扩容机制
③通过哈希值计算数据要在数组中存放的位置,并判断当前位置是否为空。
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
[i = (n - 1) & hash]
i即为下标,(当前数组的长度-1)& 哈希值,即可得到要存放在数组中的位置
如果当前位置为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;
}
}
④->(1) 判断当前位置key的哈希值和要存入的哈希值,是否相同;并且,地址相同和内容相同
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
e = p;如果相同则直接覆盖当前位置的key和value
④->(2) 判断当前位置是否为红黑树类型
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);如果是红黑树存储,使用putTreeVal()以红黑树类型插入
④->(3) 如果上述条件都不满足(则当前位置属于链表结构),则遍历链表
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;
}
}遍历链表
④->(3)->1) 如果下一个节点是否为null
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}如果为null,直接将key和value插入到当前节点
并且判断链表长度是否大于8,TREEIFY_THRESHOLD = 8,如果大于8了,则调用treeifyBin()方法,判断是否要转成红黑树结构存储。或者进行数组扩容
终止循环④->(3)->2) 如果当前位置不为null,则需要判断key的hash值和内容,是否相同
if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))
break;如果当前位置key相同了,则直接终止循环。
p = e;
将当前p值,指向下一个节点的位置,在p.next时可以继续遍历下一个节点
④->(4) 判断当前位置的值
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}如果当前位置有值,则取出旧的value,将新的值覆盖旧的值,return 旧的value,完成重复key的value值覆盖。
⑤统计修改结构次数(线程安全校验,多线程操作抛出ConcurrentModificationException
异常)
++modCount;
⑥判断长度是否超出扩容阈值
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
} // putVal()方法结束
如果当前长度超出扩容阈值,调用resize()方法进行数组扩容,返回null空值。
HashMap的扩容机制
// resize()方法
final Node<K,V>[] resize() {
// 获取到当前的数组,table为HashMap的底层存储结构,transient Node<K,V>[] table;
Node<K,V>[] oldTab = table;
// 获取当前数组的长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 旧的阈值threshold
int oldThr = threshold;
// 新的长度和阈值
int newCap, newThr = 0;
// 如果旧的长度>0 (正常扩容)
if (oldCap > 0) {
// 如果旧的长度>=MAXIMUM_CAPACITY
// static final int MAXIMUM_CAPACITY = 1 << 30;
if (oldCap >= MAXIMUM_CAPACITY) {
// 将阈值提高到MAX_VALUE
// public static final int MAX_VALUE = 0x7fffffff;
threshold = Integer.MAX_VALUE;
// 不进行实际扩容,但提升了扩容阈值(已经为最大容量)
return oldTab;
}
// 新的长度=扩容为旧的长度的2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// 新的扩容阈值=旧的阈值的2倍
newThr = oldThr << 1; // double threshold
}
// 指定容量构造方法的扩容
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
// 无参构造方法的扩容
else { // zero initial threshold signifies using defaults
// 新的长度为DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
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"})
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)
((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;
}
hashMap的扩容机制有三种情况
1 初始化扩容
使用无参构造初始化一个map集合时,初始容量为null。
使用put方法第一次添加元素时,在②中会调用resize()方法。
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;判断存放数据的数组是否为null或长度为0
oldCap的值=0
oldThr的值=0
所以走到else中
else { // 零初始阈值表示使用默认值
// 新的长度为DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
newCap = DEFAULT_INITIAL_CAPACITY;//扩容新的长度为16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//新的扩容阈值0.75*16
}
2 链表长度>8 and 数组<小于64扩容
④->(3)->1)中,链表长度>8,进入treeifyBin方法
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st TREEIFY_THRESHOLD =8
treeifyBin(tab, hash);
当判断到链表长度>8时,调用treeifyBin方法if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) // MIN_TREEIFY_CAPACITY = 64
resize();
当判断数组的长度小于64时,调用resize方法此时oldCap的长度必然>0
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
先判断 if (oldCap >= MAXIMUM_CAPACITY) 数组长度是否超过最大值(一般不会超过)
oldCap << 1 将数组长度扩大1倍
newThr = oldThr << 1相应扩容阈值扩大一倍
3 达到扩容阈值扩容
在⑥中添加元素完成后,判断是否超过扩容阈值
if (++size > threshold)
resize();
同2的扩容方式