本文解析了HashMap在添加元素时的扩容策略，重点介绍了当发生哈希碰撞时如何处理，包括数组扩容、链表转红黑树的过程。
首先，new一个Hashmap，先看看它最基本的构造方法
HashMap<Object,Object> map = new HashMap<>();
Hashmap定义的一些变量源码：
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;//默认初始容量2的四次方16
static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量2的三十次方
static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认负载系数
static final int TREEIFY_THRESHOLD = 8;//链表长度大于8
static final int UNTREEIFY_THRESHOLD = 6;//如果链表长度降低到6，变回链表
static final int MIN_TREEIFY_CAPACITY = 64;//并且数组长度大于64才转变成红黑树
Hashmap本身属性源码
transient Node<K,V>[] table;//数组
transient Set<Map.Entry<K,V>> entrySet;//链表
transient int size;//大小
transient int modCount;
int threshold;//阙值
final float loadFactor;//负载系数
构造时的源码：
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
看起来只是将负载系数设置成了默认的0.75，
接着执行put方法
map.put(1, 1);
查看源码：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
可以看到，这里执行了一个putVal方法，传入了几个参数
我们先从hash(key)看起
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
key等于null的时候返回0，不是零的时候就是取他的一个哈希值，这里移位运算就不细说了
接着我们进入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;
}
别的不说，够长
不过大部分都是用来判断红黑树的，
我们这是第一次添加，因此暂时先抛开红黑树不谈
可以看到，之前传入的参数
return putVal(hash(key), key, value, false, true);
实际上是
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict)
名字上就能看出来，传入了一个hash值，一个键，一个值，一个onlyIfAbsent，意思是是否替换相同值，默认是false（false是替换，evict表是否在创建模式，默认为true。（用于Linkedhashmap
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
进入第一个判断
很明显，只有初始化的时候，table也就是数组才等于null，或者数组的长度等于0
因此进入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;
}
让我们逐步分解
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
刚开始依然是定义了一下，oldTab就等于当前的数组
oldCap这里判断意思是，如果当前数组等于null，oldCab就是0，否则就取数组长度
oldThr等于threshold，阙值
默认newCap新容量为0，newThr新阙值为0
接着进入if的判断中
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);
}
oldCap等于0，第一个if跳过
然后轮到else if,<<1 意思可以看作除2
判断就是，新长度newCap =旧长度oldCap /2，还是0，
小于最大容量MAXIMUM_CAPACITY ，这个是满足的
并且老容量oldCap 大于默认初始容量DEFAULT_INITIAL_CAPACITY，这个明显不满足
因此这个判断也跳过
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
oldThr旧阙值现在才第一次添加呢，所以是0，这个也跳过
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
可以看到现在上面的英文注释，也就是源码本身就有的注释也表明了
这个else就是为了初始化存在的
newCap新容量等于DEFAULT_INITIAL_CAPACITY默认初始容量，也就是十六
新阙值newThr = 负载系数×初始容量，负载系数是0.75，也就是16*0.75=12
为啥会有阙值这个东西呢，要知道，hash表是要避免hash碰撞的
如果数组的容量/现有数据越多
也就是数组的使用率越高，进行hash碰撞的概率就会越大，所以要设定一个负载系数避免一些碰撞
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
接着就是把新阙值赋值，
注解不在我们讲解的内容中可以不用例会
创建一个新数组，newTab
然后覆盖掉老数组。。。。？等等，数据呢？
这就要看接下来的源码：
if (oldTab != null)
一开始就要进行判断，oldTab不等于空就进入判断，所以很明确，如果是null的话，就直接返回了，反正原数组没元素，所以直接覆盖老数组是没啥毛病的
因此这里没进入这个if判断，直接
return newTab;
返回值
到这里如果是初始化的话扩容就结束了，
下面内容涉及红黑树篇幅可能长些，因此留到下篇来写，（在写了在写了
接着回到putVal方法
恍如隔世啊
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);
进行扩容后，n就等于扩容后的长度也就是16了
然后进入判断，
p是个空结点，等于数组tab的[n-1] & hash]
听起来很拗口
不过在这里采用&也是很正常的做法，为啥不直接取余数，因为&是比取余操作的时间快很多的
可以理解为这样是通过hash值计算出应该把这个结点放在数组的哪一个位置
其中n-1&hash，保证了计算出来的值小于等于15，使得数组不会越界
（同时，Hashmap由于容量基本都是2的次幂，最终可以达到一个较好的散列效果，大家可以试试如果不是2的次幂的话，计算一下&操作符得到的数字）
如果等于null，就是证明没有hash冲突，就直接把新结点放入数组即可。
如果数组不为空呢?也就是如果发生了hash冲突，就需要用到链表了
进入到else，新建结点 与 泛型k
不得不说这个else实在是有点长
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;
}
}
首先就是创建好结点和泛型
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
p.hash，注，这个p指的是数组里的结点，
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
在前面进行判断的时候已经给p赋值了
所以
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
如果p.hash，就是原数组的哈希值，等同于现在要添加进来的hash值，并且
将p.key赋值给k后，k与将添加的key相同或者key不等于null并且key.equals(k)相等
听起来复杂
其实就是，如果原数组的哈希值与传进来的结点的哈希值相等的情况下，
如果俩个key进行相比较，完全一致的情况下，达成判断
进行e=p的赋值，也就是将传进来的结点覆盖已经有的结点。
这个是如果传进来一个完全相同的key值的时候发生的情况
我们现在是假若hash值计算出的位置相同，或者hash值相同实际值不同的情况
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
接下来这个判断是基于红黑树的，所以暂时留给下一篇来讲
接下来就是进入else的判断了
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中的一个，就break了
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，依然是先赋值，如果当前遍历到的p的下一个结点，也就是p.next为空
就直接新建一个结点，然后将现在这个结点的下一个结点指向它。
就可以结束循环了
第一个if里面的if依然是涉及到了红黑树，留到下一篇来讲
如果第一个if不满足
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
第二个if可以看到和之前的是一样的，如果hash值一样巴拉巴拉，
就是俩个值完全相等，就结束循环，赋值操作留给后面
e现在经过赋值，所以现在指向的是p的下一个结点
p=e意思就是直接遍历到下一个结点了
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
然后进入下面的if循环
e是p的下一个结点
所以如果他不为空，但是又结束循环了，证明是因为满足了上面的第二个if，也就是传入的key和原有的key相同
因此先新建个变量oldValue，这是原有的结点的value值
如果，这时候就能看到onlyIfAbsent 这个参数的意义了，
||俩边的判断如果有一方成立便等于成立
所以onlyIfAbsent 为false，便总是进行替换
使得e结点的value 等于传进来的value
或者旧结点的value为null时也进行替换
afterNodeAccess(e);
这个在Hashmap中是个空方法，所以无需管，这是在LInkedHashmap中重写的方法
接着返回原数组的value
有关Hashmap添加元素如果碰到Hash值碰撞后的源码解析就到此为止了
总结
可以看到，Hashmap本质上其实是结点Node数组加上单向链表，加上定义了一些阙值，如果达成阙值，便转换成红黑树，本篇文章暂不涉及红黑树，下篇文章会讲。
红黑树在这
扫一扫
171万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
