java集合—— HashMap源码解析
该系列都是基于JDK 8
一、基础常量以及结构
//数组默认初始容量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//数组容量最大值
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认扩容因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//链表长度阈值 树化条件
static final int TREEIFY_THRESHOLD = 8;
//树中只有6个或一下转化成链表
static final int UNTREEIFY_THRESHOLD = 6;
//树化的条件之一 数组长度需要达到的值
static final int MIN_TREEIFY_CAPACITY = 64;
// 默认的数组
transient Node<K,V>[] table;
//判断是否扩容的大小 因子*容量
int threshold;
//扩容因子
final float loadFactor;
都应该知道HashMap 的结构是数组+链表，链表会在一定条件下树化变成红黑树（本节我们只追究常规操作，不深究红黑树这种数据结构），结构如下图所示
二、构造方法
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
//扩容因子
this.loadFactor = loadFactor;
//扩容阈值
this.threshold = tableSizeFor(initialCapacity);
}
//实现了把一个数变为最接近的2的n次方 比如：7变成8 10变成16
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
我们可以看到初始化的时候传的参数是初始容量大小和扩容因子，为什么在初始化的时候并没看看数组容量的初始化，反而把数组容量赋值给了扩容阈值，阈值还没*扩容因子？为什么数组容量的初始化要做2的n次方处理？
问题一：数组容量什么时候初始化的？扩容阈值什么时候计算的？
在对象第一次Put操作的时候初始化的，有点类似懒加载的方式，只有在用时候我才申请空间资源
下面是取证，我就直接截图了，具体过程后面会说（可以看到初始化的时候把阈值给了数组长度，而阈值重新计算了一次）
问题二：为什么数组容量要设置成2的n次方？
因为HashMap是根据Key的Hash去确定在数组中的具体下标，HashMap为了减少数据碰撞（下标冲突），就需要使得数据分布更均匀，那就是取模算法 hashcode%length（数组长度），计算机直接求余数不如位运算效率高，所以源码中做了优化，使用hashcode&（length-1），hashcode%length等于hashcode&(length-1)的前提是length是2的n次幂。
三、put操作
其实我们在了解HashMap的结构后，已经猜得到添加操作需要做什么了
- 数组为空的时候，扩容初始化（正如我们上面说的一样）
- 根据要插入key的hash算出在数组中的下标（hashcode&(length-1)），看看是否已经存在，不存在则新建节点直接放入
- 如果已经存在则判断先头节点的hash、key与要插入的key、hash是否一致，一致则替换
- 不一致致需要判断这个节点是树结构还是链表结构
- 树结结构则查找树 存在则替换，不存在给树新添一个树节点
- 链表结构则遍历链 存在则替换，不存在则在尾部新添一个节点，并判断链表的长度是否达到树化条件
- 以上需要替换的节点都会被取出，新值替换旧值，并返回旧值
- 到了这说明是新添加了一个节点，需要把容量+1，并判断是否达到扩容标准，达到了还要扩容操作
源码如下：
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;
}
//(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;
// hash值和key都一致则进行替换
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) {
e = p;
}
else if (p instanceof TreeNode) {
//存储的节点的key的不存在，判断是否为树节点（是不是已经转化为红黑树）
//如果已经是树了，那就进行树的操作
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;
}
}
// 存在映射的key，覆盖原值，将值返回
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null) {
e.value = value;
}
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//hashmap的容量大于阈值
if (++size > threshold) {
// 扩容
resize();
}
afterNodeInsertion(evict);
return null;
}
四、resize 扩容机制
HashMap的扩容与正常的数组扩容没啥区别都是要新建一个扩容后的数组再讲数据填进去：
- 以前的数组长度>0 则将长度翻一倍，阈值也翻一倍
- 如果以前数组长度≤0,阈值>0 ,则将旧的阈值给新的长度(初始化数组的情况)
- 如果以前数组长度、阈值都≤0，则新的数组将设置为默认长度以及阈值
- 上述都设置完成如果新的阈值还为0，则根据新的长度*扩容因子重新设置
- 然后就要遍历旧的数组，将旧数组数据转移到新的数组上面（转移时数据需要重新计算下标）
- 旧数据里面的节点数据如果下一个指向为空，说明只有一个节点，直接转移过去即可
- 不为空则可能是树结构或者是链表，两者都要遍历切割为高低位节点（树结构切割后还需判断长度是否≤6，满足则重新转为链表结构），然后再赋值过去（下面说为什么要切割）
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) {
// 旧的数组长度>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
// 旧的长度<=0 且 旧的阈值 >0 就把新的长度设置成旧的阈值
newCap = oldThr;
}
else { // zero initial threshold signifies using defaults
// 如果旧的长度、阈值都为0 就重新设置新的长度和阈值为默认值
newCap = DEFAULT_INITIAL_CAPACITY;
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"})
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 {
// 说明节点是链表
//低位链表：存放在扩容之后的数组的下标位置，与当前数组下标位置一致
//loHead：低位链表头节点
//loTail低位链表尾节点
Node<K,V> loHead = null, loTail = null;
//高位链表，存放扩容之后的数组的下标位置，=原索引+扩容之前数组容量
//hiHead:高位链表头节点
//hiTail:高位链表尾节点
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
//高位为0，放在低位链表
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
//高位为1，放在高位链表
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//低位链表已成，将头节点loHead指向在原位
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//高位链表已成，将头节点指向新索引
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
问题一：为什么要切割分为高低位节点，直接转过去不好吗？
因为数组长度越小发生数组下标冲突的几率越大，所以对于已经冲突形成链表或树结构的下标数据需要重新根据新的数组长度计算数组下标值，再转移到新数组；（这也是为什么数组长度≥64的时候才可以树化，这之前都是选择扩容）
如下图所示：
两个数据在扩容前是下标冲突的，下标都是5，在扩容后：高位为1的数据，下标已经变成了21，正好是之前的下标+原数组长度，这也是为什么上述源代码里面高位链表在放到新数组里面的时候下标会加上数组长度的原因；这时候有人疑惑，你这是(hash&length-1)啊，源代码里面可是(hash&length)，细心的人已经发现了两者是一样的道理，前者是计算下标，后者是判断是否高低位，下图只是为了更好的理解
这也是把长度设计成2的n次方的牛逼之处
五、treeifyBin树化
可以看到只有当数组长度≥64才会树化，没满足的情况下是扩容操作
树化的时候可以看到树化前是将节点转化成了树节点，而且树节点同时还是一个双向链表
真正的树化操作是treeify()方法（不深究，有兴趣的可以研究下红黑树结构）
源代码如下：
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
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);
}
}
六、get操作
这个思路是一样的看着HashMap的结构就能猜到获取思路了：
- 判断数组是否为空，节点是否存在
- 对比节点的hash与key值是否一致，一致则返回
- 判断节点下一个指向是否为空，不为空则要判断是否节点是树结构
- 树结构则获取树节点，链表则遍历获取节点
源代码如下：
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//判断数组是否为空、节点是否存在
if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) {
//头结点相同直接返回
if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k)))) {
return first;
}
if ((e = first.next) != null) {
//头结点不同 且 下一个指向不为空
if (first instanceof TreeNode) {
// 树结构就获取树节点
return ((TreeNode<K, V>) first).getTreeNode(hash, key);
}
//链表结构则遍历链表
do {
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {
return e;
}
} while ((e = e.next) != null);
}
}
return null;
}
七、contains操作
containsKey
实际是get操作，get后判断是否为空 存在返回true 不存在返回：false
源代码如下：
public boolean containsKey(Object key) {
return getNode(hash(key), key) != null;
}
containsValue
遍历数组同时遍历节点，存在相等的value 返回true 不存在返回 false
为什么节点的遍历不需要考虑树节点？
上面说过了树节点其实也是双向链表
源代码如下：
public boolean containsValue(Object value) {
Node<K,V>[] tab; V v;
if ((tab = table) != null && size > 0) {
//遍历数组
for (int i = 0; i < tab.length; ++i) {
//遍历节点
for (Node<K,V> e = tab[i]; e != null; e = e.next) {
if ((v = e.value) == value ||
(value != null && value.equals(v)))
return true;
}
}
}
return false;
}
1754
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
