不花时间的导读：这是《好好面试系列》第28篇原创文，该系列主要分享小饭饭面试别人、和被别人面试的经历，该篇文章主要分享HashMap高频面试题，有兴趣的看看，已经知道的可以无视。
前几天H同学和我聊了下去谷歌的面试经验，令我诧异的是，没想到谷歌也问集合之后，我便觉得需要再整理一波集合相关的了。
看文章前可以先看看以下高频考点，如果觉得莫得问题，可以直接跳过该篇文章了，不用浪费时间。
new HashMap() 和 new HashMap(int initialCapacity) ，具体有什么区别？
HashMap中的数据多于多少个时才会进行扩容？
HashMap中的链表结构什么时候转成红黑树？一定会转吗？
红黑树结构又什么时候才会转回链表？
说说看HashMap的懒加载？负载因子的作用？
特征解析
为了搞清楚一个概念，这篇文章引入竹篮和鸡蛋的概念，缓存的数据就是鸡蛋，而节点就是竹篮，HashMap底层是一个竹篮数组，每个竹篮是一个链表或者红黑树的结构，每个竹篮也可以放多个鸡蛋，因此其实可以当成二维数组来看待，只是在这里的第二维数组是一个链表或者红黑树，至于这个竹篮的结构是链表还是红黑树，就看竹篮内的的鸡蛋个数有多少，并且链表和红黑树之间可以进行转换。
通过散列函数将鸡蛋定位到表中的具体竹篮，以提升查询速度，其底层用于存放数据的数组也叫散列表。所谓散列函数，简单来说就是将一个无限大的集合（在 HashMap 中，key值是一个无限大集合），经过 hash 运算取模，均匀的分布在一个有限的集合（我们定义的哈希表容量，比如长度 16 的数组）
源码解析
成员变量和常量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 默认的初始容量，预计所有竹篮累计可以放16个鸡蛋
static final int MAXIMUM_CAPACITY = 1 << 30; // 最大容量，所有竹篮最多可以放多少个鸡蛋
static final float DEFAULT_LOAD_FACTOR = 0.75f; // 默认加载因子，装逼用，一般都会在应用探讨bb的时候提一嘴
static final int TREEIFY_THRESHOLD = 8; // 单个竹篮放的鸡蛋个数超过8转红黑树
static final int UNTREEIFY_THRESHOLD = 6; // 单个竹篮放的鸡蛋个数小于6则转链表
static final int MIN_TREEIFY_CAPACITY = 64; // 如果竹篮个数小于64个，会先进行扩容，而不会链表转红黑树
transient Node<K,V>[] table; // 哈希表数组，存储数据的地方，每个竹篮结构可能为链表或者红黑树，总是2的幂次倍
transient Set<Map.Entry<K,V>> entrySet; // 存放具体元素的集合，可用于遍历Map
transient int size; // 总的鸡蛋个数
transient int modCount; // 插入删除元素，modCount++,用于记录改变次数
int threshold; // 容量阈值，所有竹篮允许缓存鸡蛋的个数，超过这个值需要扩容，默认为0，看看后续是如何变化的，对理解扩容那块很重要
final float loadFactor; // 加载因子，能够权衡时间复杂度和空间复杂度
笔试or面试需要记住几个死记硬背的点，那就是：hashmap的默认初始容量为16，加载因子是0.75，链表长过8则转红黑树，小于6则转链表，容量低于64则先扩容，而不会链表转红黑树。
看看构造方法
HashMap有四个构造方法，这里只列出我们常用的两个
第一个是默认构造方法，我们不指定默认所有竹篮累计可以放16个鸡蛋
第二个是指定初始容量，也是我们比较推荐的做法，根据需要设置大小，避免后面resize扩容开销
日常开发中如果知道大小，我们都会用第二种，可以避免resize扩容开销，新手开发经常会直接用第一种，一般我review代码看到都会直接打回改，然后告诉他们为啥，想想看，如果你已经知道这个map容器要装的元素是100个，你还不指定初始容量，那么就会导致在第一次put数据的时候进行扩容，此时第一次扩容因为没有初始容量，计算出的容量阈值为默认大小16，16*加载因子0.75f就是12，之后当你继续put值超过12个的时候又会继续扩容，第二次扩容后容量阈值为24，循环刚刚的过程直到容量阈值大于100，而如果指定了默认大小则第一次扩容就够用了，不用走后面那么多次扩容，可以节省性能；
其次是命名也要注意下，最好是直接用Map结合，比如xxxMap，这是规范。
扩容
我们先回顾下上面的一个成员变量threshold
「int threshold; // 容量阈值，所有竹篮允许放入鸡蛋的个数」
ok了，继续讲扩容，扩容分为多种情况
如果我们使用了无参构造方法，可以看到
其中并未对成员变量threshold容量阈值进行初始化，反调threshold赋值的地方可以看到在put第一个元素的时候会调用resize方法，该方法有做了容量阈值的计算，计算方式为：DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY，也就是默认的加载因子 * 默认容量，即 0.75f * 16，即12
如果指定了初始容量
image-20210302232344781 
image-20210302232401052 可以看到初始容量阈值的计算公式是：
这么一坨东西是啥呢，其实就是一个算法，看不懂也莫得关系，毕竟我也看不懂，记住就好，这个算法其实就是返回大于输入参数且最近的2的整数次幂的数，比如设置的初始容量为10，那么这个算法则返回16。
但是，到了这里其实也并没有分配好数组，可以看到resize方法，其实也是在put的时候才会真正进行数组的分配，也就是懒加载了。
二次扩容，最终都会走向resize方法，每次扩容量都会是原先的2倍。
我们可以看看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) {
// 如果竹篮个数大于最大容量，则将容量阈值设置成int的最大值
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 否则新阈值为旧阈值两倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1;
}
else if (oldThr > 0)
newCap = oldThr;
else {
// 只有默认无参构造方法才会走到这个分支，阈值为默认算法，容量 * 0.75
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)
// 竹篮内内的鸡蛋数据重hash，红黑树转链表的地方，内部处理主要是当竹篮内的鸡蛋个数小于等于6时，树结构会还原成链表
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
// 略：链表元素重hash
}
}
}
}
return newTab;
}
HashMap扩容可以分为三种：
使用默认构造方法初始化HashMap，从前文可以知道HashMap在一开始初始化的时候thershold容量阈值为0，默认值DEFAULT_INITIAL_CAPACITY也就是16，DEFAULT_LOAD_FACTOR为0.75f，因此在第一次put数据的时候会进行扩容，扩容后的容量阈值threshold为DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR = 12；
指定初始容量的构造方法初始化HashMap，可以看到在初始化的时候便通过tableSizeFor进行计算，也就是返回大于输入参数且最近的2的整数次幂的数；
当HashMap不是第一次扩容的时候，那么每次扩容的容量以及容量阈值threshold为原有的两倍。
hash计算
HashCode是啥其实大家都知道，无非就是用来确定对象在HashMap中的存储地址，目的也很简单，为了快，貌似除了了那方面，其他都是越快越好，比如赚钱。
元素插入
我们先回顾下上面的一个成员变量table
「itransient Node<K,V>[] table; // 哈希表数组，存储数据的地方，每个竹篮结构可能为链表或者红黑树，总是2的幂次倍」
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 这里如果发现动态数组为null则会初始化数组。
if ((tab = table) == null || (n = tab.length) == 0)
// 第一次放入值时会在这里初始化数组，并且通过resize方法进行扩容
n = (tab = resize()).length;
// 通过hash发现要放入的鸡蛋的数组位置为null，说明没有hash冲突，则直接把该鸡蛋放在这里即可
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
// 如果要放入的位置已经有该鸡蛋了
Node<K,V> e; K k;
// 判断竹篮的第一个鸡蛋否和新元素key以及hash值都完全一致，如果是则不用看代码都知道进行覆盖，覆盖的逻辑在后面
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);
// 判断链表长度是否大于8，这里其实减后为7，判断的是binCount,但是因为插入了一个新节点了，所以其实为8
if (binCount >= TREEIFY_THRESHOLD - 1)
// 则将列表转为红黑树，所以记住大于8的时候会转成红黑树
treeifyBin(tab, hash);
break;
}
// 已经找到了hash值和key一样的，则直接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;
// 当map中所有的鸡蛋个数大于容量阈值时则进行扩容，二次扩容如上面所说，也就是两倍
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
// 当tab为空或者竹篮个数小于64个，会先进行扩容，而不会链表转红黑树
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);
}
}
put总体流程汇总如下：
罗列几个该注意的点，分别是：
HashMap中缓存数据的数组table，我们可以看到初始化的时候默认是null，是在第一次put数据的时候才进行初始化的，这也是所谓的懒加载，记住了，不要每次提HashMap的懒加载机制都二脸懵逼了。
HashMap中单个竹篮存放的鸡蛋个数大于8，并且当竹篮个数大于64个的时候则将列表转为红黑树，否则进行扩容。
每次put数据时当map中存放的所有鸡蛋个数大于容量阈值时则进行扩容，并且是先put数据，再扩容。
元素查询
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) {
// 如果计算hash值和第一个节点的key值相同，直接返回
if (first.hash == hash && // always check first node
((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 {
//如果hash值相同，key不同，则遍历链表找到相同的key，返回
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
查找这里，总结下来流程便是：
根据hash值从竹篮数组内找到竹篮，判断头节点key值与当前key相同，直接返回
如果该竹篮为TreeNode节点，以红黑树方式查找
如果不是则循环遍历链表，直到查到对应的key相同
元素删除
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);
}
}
//删除node
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
//如果node为红黑树结点，采用红黑树删除方式
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
// 如果是链表并且node为头结点，当前数组下标元素直接替换为next
else if (node == p)
tab[index] = node.next;
else
//链表非头元素删除方式
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
删除操作很简单，先根据hash找到对应鸡蛋，然后根据不同类型的节点进行删除，没什么注意的点，如果有，那就是如果是链表表头的话，则需要将下一个节点赋值为表头。
最后，对开头几道题的标准答案拿不准的，先给文章点个赞、再点个在看，然后后台输入：HashMap
《好好面试》系列文目前已经连载27篇啦，
相信我，这是一个不管你在职、求职，都值得关注的一个系列。
往期推荐
第一次面试，我差点被面试官打，就因为Collections.sort
去年面了多个候选人，看看我挖的坑还有他们应该要补的Java基础(二)
去年面了多个候选人，看看我挖的坑还有他们应该要补的Java基础(一)
小饭饭：某游戏大厂高级开发，专门和主管抬杠的小组长。
目前写了三个系列文《全网最全的Caffeine教程》、《一起玩dubbo》和《好好面试》，《好好面试》分享了自己多年来面试别人和被别人面试的经验，有兴趣看面经、学dubbo和Caffeine的可以微信搜：稀饭下雪
对你有用是这篇文章值得被分享的唯一标准
2730
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
