在日常开发过程中经常会使用到HashMap这个集合；在保证会使用的基础上，咱们来一起探索HashMap的底层实现；
为什么使用HashMap
在开发过程中会遇到以下场景：将 从数据库查询出的数据或者经过计算得到的数据 通过KV键值对的方式暂时储存起来，等到用的时候只需要根据指定的Key便能获取到对应的Value，这种方式既方便又快速；但是你有没有考虑过在使用过程中应该注意哪些点，或者说会出现哪些问题？带着这些疑问大家一起看下面的解析；
HashMap的底层实现
本文以JDK1.8为例进行说明；
首先关注一下HashMap源码中的一些重要属性；从下面的属性中可以得知HashMap的底层数据结构为 数组 + 链表 + 红黑树；默认初始容量为16，最大容量为2的30次幂（note:容量必须为2的n次幂），扩容时的负载因子默认为0.75，还有一些与红黑树相关的属性；
// 数组
transient Node<K,V>[] table;
// 单链表
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
}
// 默认数组初始容量为16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
// 数组容量的最大值为2的30次幂（容量必须为2的n次幂）
static final int MAXIMUM_CAPACITY = 1 << 30;
// 数组进行扩容时的负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 链表转变为红黑树条件一：链表长度大于等于8（注：条件一和条件二需同时满足）
static final int TREEIFY_THRESHOLD = 8;
// 链表转变为红黑树条件二：数组长度大于64
static final int MIN_TREEIFY_CAPACITY = 64;
// 链表长度小于等于6时，红黑树转变为链表
static final int UNTREEIFY_THRESHOLD = 6;
HashMap插入元素过程
通过调用 put(K key, V value) 方法添加元素，下面根据HashMap源码简单分析一下添加元素的过程：
// 添加元素
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
- 获取key的hash值，将key对应hashCode值的高16位与低16位进行异或（^）运算；
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
- 根据获取的hash值与HashMap的容量减一进行&运算，计算出key要插入数组的位置；如果数组中对应的位置没有元素，则直接将该KV键值对插入到数组中；
- 如果数组中有元素，则判断是否是TreeNode，是的话以红黑树的方式去操作，如果不是的话就认为是单链表，以尾插法的方式插入新元素；接着再判断链表的长度是否大于等于8，如果大于等于8,，会调用treeifyBin方法，该方法中会判断数组长度的是否大于64，如果大于则转换为红黑树，否则的话就对数组进行扩容；所以链表转换为红黑树需要满足两个条件：单链表的长度大于等于8并且数组的长度大于64；
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)
// 没有元素，直接将KV键值对插入
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
// 判断key是否相等
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);
// 判断单链表的长度是否大于等于7（注意binCount的值是从0开始的）
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 红黑树相关的逻辑，该方法中会有 数组的长度是否大于64的判断
treeifyBin(tab, hash);
break;
}
// 判断要插入的Key是否与链表中的该节点相等
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 数组和链表中存在与要插入的Key相等的key
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
// 进行value数据覆盖
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
// 判断已存入元素个数是否大于容量阈值
if (++size > threshold)
// 扩容
resize();
afterNodeInsertion(evict);
return null;
}
HashMap扩容过程
当HashMap中数组中的元素超过HashMap的阈值（HashMap容量*负载因子）时，HashMap将会调用resize()方法进行扩容（上面putVal方法的最后有这个对应的代码）；
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)
// 扩容后的阈值扩大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
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;
// 当老HashMap中存在元素时
if (oldTab != null) {
// 老HashMap中的数据进行重新ReHash;通过重新ReHash将老数据放入新HashMap中
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
// 如果该位置没有链表时（即不存在Hash冲突）
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;
// 通过看结果是否等于0，来判断位于老数组的位置是否需要移动
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;
}
咱们主要看一下上述代码中if分支的最后一个else代码块中的代码；最后一个else代码块中的代码主要是为了处理原HashMap中由于Hash冲突产生的单链表；通过每个单链表中的元素的Hash值与原HashMap容量进行&运算后的结果是否为0，来判断该节点是否需要移动位置；通过该计算将原HashMap中的单链表分为两部分，一部分还是在原来的位置上，另一部分在 原来的位置 + 原来的HashMap容量 上；这样在扩容时，能够更快更方便的将两个链表放在新的数组对应的位置上；
感谢大家的阅读，如您在阅读过程中有什么疑问或者发现了什么错误，请您在评论区留言，大家一起交流与学习。
- 我正在参与掘金技术社区创作者签约计划招募活动，点击链接报名投稿。
