HashMap的源码分析
目录
2.2 HashMap(int initialCapacity)构造方法
2.3 HashMap(int initialCapacity, float loadFactor)构造方法
1.HashMap的结构
Java中的HashMap采用数组加链表的形式，话不多说，先贴代码
可以看到，该Node结点的属性有四个 hash, key, value, 以及一个Node类型的next。hash属性则是key通过hash()方法运算得来。
2.HashMap的构造方法
上图
2.1 HashMap()构造方法
该构造方法中仅对一个成员变量loadFactor进行初始化，loadFactor是负载因子，默认下为0.75，它的作用举个例子说明下。我们HashMap初始化大小默认为16，也就是new Node[16], 此时如果这个Node数组中的使用量达到 16 * loadFactor时，HashMap会进行扩容。有关扩容放在后续进行详解。
2.2 HashMap(int initialCapacity)构造方法
该构造方法实则调用HashMap(int initialCapacity, float loadFactor)方法，为loadFactor负载因子设置默认值。
2.3 HashMap(int initialCapacity, float loadFactor)构造方法
该方法我们可以看到对两个参数进行了严格的校验
loadFactor我们知道了是负载因子 ，那initialCapacity和 threShold呢？我们可以看到最后一行
其实这个tableSizeFor方法我们也可以从方法名猜到，就是指定对我们创建的那个数组的大小。
3.HashMap的put方法
可以看到在put方法中世纪调用的是putVal方法 我们详细了解下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)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
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;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}在使用put方法时， 我们只需要传 key 与 value就行，对于其他三个参数put方法为我们自动传参，第一个hash其实就是key值经过hash()方法获得，后两个boolean值稍后再说。
================================================================================================
当我们new了一个HashMap时，此时向HashMap中添加数据，调用put(key,value)方法，我们会看到一开始下面的逻辑
代码先创建了一个结点数组 tab和一个单独的结点 p， 创建了两个int变量 n， i，然后将table赋值给tab，这个table是什么呢？
table是HashMap的一个成员变量
，也就是我们HashMap的内部用来存放key value的那个数组+链表的数据结构。我们在new一个HashMap的时候也没见构造方法对该table初始化，所以此时table为null。
table为null，于是走入了该代码逻辑中，并将table数组的length赋值给n，我们可以看到有个resize()方法。该方法的作用是对HashMap进行扩容，如果table是空的对table初始化。关于resize()方法后面再讲。
================================================================================================
接下来代码进入
进行逻辑判断。p = tab[i = (n-1)&hash]==null
该段代码中 n-1代表table的size-1，(n -1)&hash是我们应该存放在数组的那个位置，并将该位置的Node结点赋值给p。如果p == null，说明该位置没有元素，我们就将元素插入该位置，代码也就基本执行完了。
================================================================================================
如果说上面的逻辑没有执行到，那接下来就是进入这块代码，也就是各篇文章所说的桶中去添加元素了。
在这里代码创建了一个Node变量e，以及 put进来的key键类型的k。 p则是我们上段代码讲的该位置的Node结点，这里讲讲if中的代码执行逻辑：1.先判断当前结点的hash值是否与我们插入的hash值一致，如果一致进入后面的判断，不一致就终止。 2.判断当前结点的key与我们要插入的key是否相等，如果相等就将e也指向当前结点（至于为什么要这么判断可以去看看equals和hash的关系）
然后进入代码
当前代码逻辑也就是将我们插入的值覆盖到当前结点(因为上面那个if已经判断了key相等),至于onlyIfAbsent则是默认的false，所以这块的代码只要当前结点不是空一定会执行的。 afterNodeAccess方法在HashMap中是个空方法，在linkedHashMap中实现了这一方法，这里先不管。
================================================================================================
如果没有进入上面的逻辑中，那么程序就执行下面这块逻辑
关于else if(p instanceof TreeNode) 这里是判断这个结点所在的桶是否由链表变为红黑树。博主比较菜，看不懂那里的代码
我们看到有个for循环，在该for循环中不难看到，其实是从p结点也就是第一个结点的下一个结点开始进行判断：如果下个节点是空的，就插入到下个结点；如果不是空的，就要判断是否key相等并覆盖，如此循环。 其中要注意的是treeifyBin方法，在jdk1.8后如果桶中的结点数量大于8个就要将链表结构转为红黑树。
================================================================================================
最后就是我们最后的代码了
我们回顾一下前面的代码，如果进入到了下面这段代码，也就是e不为空，e不为空意味着我们插入到的桶是一个已经有元素存在的桶，然后代码就终止了。
所以说只有在put操作插入到一个非空的桶中才会对modCount++（版本号）以及扩容检测操作,afterNodeInsertion方法是一个空方法，用户可以继承HashMap重写该方法。
到这里put方法的解析就结束了。
4.HashMap的resize()方法
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 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
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
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;
}resize()方法在我们put()的时候会去检测是否达到扩容条件并扩容。
================================================================================================
看看我们第一处的代码逻辑
首先定义了 oldCap变量去拿table的size大小，oldThr去拿threshold。threshold在这里有不同的含义：1.如果从未put过数据，此时的threshold会是原来在构造函数中传的值，也就是后面要创建的table的大小；2.如果put了数据，此时的threshold则是table的大小*loadFactor。其次定义了两个变量newCap和newThr，从命名看newCap也就是新table的大小，newThr是新表的大小*loadFactor。
（后面的代码较简单，不再一行一行分析了） 1.如果table大小>0，newCap为原table大小的2倍，newThr为newCap*loadFactor。如果newCap大小超过最大值 newThr则不进行赋值。
2.如果table大小不大于0 且 oldThr>0，newCap=oldThr，此时的newCap也就是我们构造函数传过来的值的大小。
3.如果都不满足上述条件，那么newCap和newThr则都取默认值。newCap=16，newThr=16*0.75
===============================================================================================
上面不过走哪处逻辑，接下来都会执行这段代码
newThr==0的情况 只有走了上面的else if片段才会执行，也就是给newThr赋值为newCap*loadFactor（正常情况下），没什么好讲的。然后创建新表，大小为newCap，并将table指向新表，将newThr赋值给threold。
================================================================================================
然后就是后面这段看起来超长的代码
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;
}
}
}
}
}学过数据结构就很容易啃的动，先大致讲一下这段代码做了什么处理。
这里有个for循环oldTable，作用是想在循环体内将旧table的元素一个一个拿到新table中。具体操作如下：
1.从第数组第一个位置的结点出发，如果当前结点不为空但是当前结点的next结点为空，直接将结点挪到新的table中（新的位置还是用hash和新table的大小做&运算）。如果当前结点为空没什么好说的，进入下一次循环。
2.当前结点不仅不为null 且 next也不为null，则会将当前链表循环一遍，每个结点的key键与oldCap（旧表大小）做&运算，值为0的插入到loHead结点后， 其他的放在hiHead结点后， loHead结点开始的这个链表插在新表的位置和旧表相同（比如下标为6），hiHead结点开始的表插入在loHead结点所在位置加上旧表的大小（6+16）。
至此resize()方法结束
5.HashMap的remove()方法
//matchValue默认false，movable为true
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
tab[index] = node.next;
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;================================================================================================
remove方法很简单，这里讲一下remove的流程：
1.找到key对应的桶的位置，从该位置开始判断。
2.如果开始的结点为null，结点不存在，结束；如果结点存在并且key相等，将开始节点赋值为当前结点的next结点。
3.如果开始的结点没有匹配上，在后面的桶中匹配到了相同的结点，则就是一个简单的删除链表中结点的操作。
4.如果删除成功，返回删除的值；否则返回null
286
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
