HashMap保存键值对数据的步骤总结

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的扩容方式