最新绝了！这是我见过最详细的HashMap源码解析，字节跳动社招java面试

最后

小编精心为大家准备了一手资料

以上Java高级架构资料、源码、笔记、视频。Dubbo、Redis、设计模式、Netty、zookeeper、Spring cloud、分布式、高并发等架构技术

【附】架构书籍

1. BAT面试的20道高频数据库问题解析
2. Java面试宝典
3. Netty实战
4. 算法

BATJ面试要点及Java架构师进阶资料

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

至此tableSizeFor如何保证cap为2的幂次方已经显而易见了,那么问题来了

4.1 为什么cap要保持为2的幂次方？

---

主要与HashMap中的数据存储有关.

在Java8中,HashMap中key的Hash值由Hash(key)方法计得

HashMap中存储数据table的index是由key的Hash值决定的.

在HashMap存储数据时,我们期望数据能均匀分布,以防止哈希冲突.

自然而然我们就会想到去用%取余操作来实现我们这一构想

取余(%)操作 : 如果除数是2的幂次则等价于与其除数减一的与(&)操作.

这也就解释了为什么一定要求cap要为2的幂次方.再来看看table的index的计算规则：

等价于:

index = e.hash % newCap

采用二进制位操作&,相对于%,能够提高运算效率,这就是cap的值被要求为2幂次的原因

4.2 Node类

---

static class Node<K,V> implements Map.Entry<K,V> {

final int hash;

final K key;

V value;

Node<K,V> next;

Node(int hash, K key, V value, Node<K,V> next) {

this.hash = hash;

this.key = key;

this.value = value;

this.next = next;

}

public final K getKey() { return key; }

public final V getValue() { return value; }

public final String toString() { return key + “=” + value; }

public final int hashCode() {

return Objects.hashCode(key) ^ Objects.hashCode(value);

}

public final V setValue(V newValue) {

V oldValue = value;

value = newValue;

return oldValue;

}

public final boolean equals(Object o) {

if (o == this)

return true;

if (o instanceof Map.Entry) {

Map.Entry<?,?> e = (Map.Entry<?,?>)o;

if (Objects.equals(key, e.getKey()) &&

Objects.equals(value, e.getValue()))

return true;

}

return false;

}

}

Node<K,V> 类是HashMap中的静态内部类,实现Map.Entry<K,V>接口.定义了key键、value值、next节点,也就是说元素之间构成了单向链表.

4.3 TreeNode

---

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {

TreeNode<K,V> parent; // red-black tree links

TreeNode<K,V> left;

TreeNode<K,V> right;

TreeNode<K,V> prev; // needed to unlink next upon deletion

boolean red;

TreeNode(int hash, K key, V val, Node<K,V> next) {}

// 返回当前节点的根节点

final TreeNode<K,V> root() {

for (TreeNode<K,V> r = this, p;😉 {

if ((p = r.parent) == null)

return r;

r = p;

}

}

}

红黑树结构包含前、后、左、右节点，以及标志是否为红黑树的字段

此结构是Java8新加的

4.4 hash方法

---

Java 8中的散列值优化函数

只做一次16位右位移异或

key.hashCode()函数调用的是key键值类型自带的哈希函数，返回int型散列值

理论上散列值是一个int型，如果直接拿散列值作为下标访问HashMap主数组的话，考虑到2进制32位带符号的int范围大概40亿的映射空间。只要哈希函数映射得比较均匀松散，一般应用是很难出现碰撞的。

但问题是一个40亿长度的数组，内存是放不下的.HashMap扩容之前的数组初始大小才16,所以这个散列值是不能直接拿来用的.

用之前还要先做对数组的长度取模运算，得到的余数才能用来访问数组下标

源码中模运算就是把散列值和数组长度做一个"与"操作，

这也正好解释了为什么HashMap的数组长度要取2的整次幂

因为这样（数组长度-1）正好相当于一个“低位掩码”

“与”操作的结果就是散列值的高位全部归零，只保留低位值，用来做数组下标访问

以初始长度16为例，16-1=15

2进制表示是00000000 00000000 00001111

和某散列值做“与”操作如下，结果就是截取了最低的四位值

但这时候问题就来了,这样就算我的散列值分布再松散,要是只取最后几位的话,碰撞也会很严重

这时候“扰动函数”的价值就体现出来了

右位移16位，正好是32位一半，自己的高半区和低半区做异或，就是为了混合原始hashCode的高位和低位，以此来加大低位的随机性

而且混合后的低位掺杂了高位的部分特征，这样高位的信息也被变相保留下来。

index的运算规则是

e.hash & (newCap - 1)

newCap是2的幂,所以newCap - 1的高位全0

若e.hash值只用自身的hashcode,index只会和e.hash的低位做&操作.这样一来,index的值就只有低位参与运算,高位毫无存在感,从而会带来哈希冲突的风险

所以在计算key的hashCode时,用其自身hashCode与其低16位做异或操作

这也就让高位参与到index的计算中来了,即降低了哈希冲突的风险又不会带来太大的性能问题

4.5 Put方法

---

①.判断键值对数组table[i]是否为空或为null，否则执行resize()进行扩容

②.根据键值key计算hash值得到插入的数组索引i，如果table[i]==null，直接新建节点添加，转向⑥，如果table[i]不为空，转向③

③.判断table[i]的首个元素是否和key一样，如果相同直接覆盖value，否则转向④，这里的相同指的是hashCode以及equals

④.判断table[i] 是否为treeNode，即table[i] 是否是红黑树，如果是红黑树，则直接在树中插入键值对，否则转向⑤

⑤.遍历table[i]，判断链表长度是否大于8，大于8的话把链表转换为红黑树，在红黑树中执行插入操作，否则进行链表的插入操作；遍历过程中若发现key已经存在直接覆盖value即可

⑥.插入成功后，判断实际存在的键值对数量size是否超多了最大容量threshold，如果超过，执行resize()扩容

public V put(K key, V value) {

// 对key的hashCode()做hash

return putVal(hash(key), key, value, false, true);

}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {

Node<K,V>[] tab; Node<K,V> p; int n, i;

// 步骤① tab为空则调用resize()初始化创建

if ((tab = table) == null || (n = tab.length) == 0)

n = (tab = resize()).length;

// 步骤② 计算index,并对null做处理

//tab[i = (n - 1) & hash对应下标的第一个节点

if ((p = tab[i = (n - 1) & hash]) == null)

// 无哈希冲突的情况下,将value直接封装为Node并赋值

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)

// p是红黑树类型，则调用putTreeVal方式赋值

e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);

// 步骤⑤ p非红黑树类型,该链为链表

else {

// index 相同的情况下

for (int binCount = 0; ; ++binCount) {

if ((e = p.next) == null) {

// 如果p的next为空,将新的value值添加至链表后面

p.next = newNode(hash, key, value, null);

if (binCount >= TREEIFY_THRESHOLD - 1)

// 如果链表长度大于8,链表转化为红黑树,执行插入

treeifyBin(tab, hash);

break;

}

// key相同则跳出循环

if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))

break;

//就是移动指针方便继续取 p.next

p = e;

}

}

if (e != null) { // existing mapping for key

V oldValue = e.value;

//根据规则选择是否覆盖value

if (!onlyIfAbsent || oldValue == null)

e.value = value;

afterNodeAccess(e);

return oldValue;

}

}

++modCount;

// 步骤⑥:超过最大容量,就扩容

if (++size > threshold)

// size大于加载因子,扩容

resize();

afterNodeInsertion(evict);

return null;

}

在构造函数中最多也只是设置了initialCapacity、loadFactor的值,并没有初始化table,table的初始化工作是在put方法中进行的.

4.6 resize

---

扩容(resize)就是重新计算容量,向HashMap对象里不停的添加元素,内部的数组无法装载更多的元素时,就需要扩大数组的长度.

当然Java里的数组是无法自动扩容的,方法是使用一个新的数组代替已有的容量小的数组

/**

• 该函数有2种使用情况：1.初始化哈希表 2.当前数组容量过小，需扩容

*/

final Node<K,V>[] resize() {

Node<K,V>[] oldTab = table;

int oldCap = (oldTab == null) ? 0 : oldTab.length;

int oldThr = threshold;

int newCap, newThr = 0;

// 针对情况2：若扩容前的数组容量超过最大值，则不再扩充

if (oldCap > 0) {

if (oldCap >= MAXIMUM_CAPACITY) {

threshold = Integer.MAX_VALUE;

return oldTab;

}

// 针对情况2：若无超过最大值，就扩充为原来的2倍

else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&

oldCap >= DEFAULT_INITIAL_CAPACITY)

//newCap设置为oldCap的2倍并小于MAXIMUM_CAPACITY，且大于默认值, 新的threshold增加为原来的2倍

newThr = oldThr << 1; // double threshold

}

// 针对情况1：初始化哈希表（采用指定 or 默认值）

else if (oldThr > 0) // initial capacity was placed in threshold

// threshold>0, 将threshold设置为newCap,所以要用tableSizeFor方法保证threshold是2的幂次方

newCap = oldThr;

else { // zero initial threshold signifies using defaults

// 默认初始化

newCap = DEFAULT_INITIAL_CAPACITY;

newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);

}

// 计算新的resize上限

if (newThr == 0) {

// newThr为0，newThr = newCap * 0.75

float ft = (float)newCap * loadFactor;

newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?

(int)ft : Integer.MAX_VALUE);

}

threshold = newThr;

@SuppressWarnings({“rawtypes”,“unchecked”})

// 新生成一个table数组

Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];

table = newTab;

if (oldTab != null) {

// oldTab 复制到 newTab

for (int j = 0; j < oldCap; ++j) {

Node<K,V> e;

if ((e = oldTab[j]) != null) {

oldTab[j] = null;

if (e.next == null)

// 链表只有一个节点，直接赋值

//为什么要重新Hash呢？因为长度扩大以后，Hash的规则也随之改变。

newTab[e.hash & (newCap - 1)] = e;

else if (e instanceof TreeNode)

// e为红黑树的情况

((TreeNode<K,V>)e).split(this, newTab, j, oldCap);

else { // preserve order链表优化重hash的代码块

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;

}

// 原索引 + oldCap

else {

if (hiTail == null)

hiHead = e;

else

hiTail.next = e;

hiTail = e;

}

} while ((e = next) != null);

// 原索引放到bucket里

if (loTail != null) {

loTail.next = null;

newTab[j] = loHead;

}

// 原索引+oldCap放到bucket里

if (hiTail != null) {

hiTail.next = null;

newTab[j + oldCap] = hiHead;

}

}

}

}

}

return newTab;

}

4.7 remove方法

---

remove(key) 方法 和 remove(key, value) 方法都是通过调用removeNode的方法来实现删除元素的

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))))

// index 元素只有一个元素

node = p;

else if ((e = p.next) != null) {

if (p instanceof TreeNode)

// index处是一个红黑树

node = ((TreeNode<K,V>)p).getTreeNode(hash, key);

else {

// index处是一个链表，遍历链表返回node

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;

}

4.8 get

---

/**

• 函数原型

• 作用：根据键key，向HashMap获取对应的值

*/

map.get(key)；

/**

• 源码分析

*/

public V get(Object key) {

Node<K,V> e;

// 1. 计算需获取数据的hash值

// 2. 通过getNode（）获取所查询的数据 ->>分析1

// 3. 获取后，判断数据是否为空

return (e = getNode(hash(key), key)) == null ? null : e.value;

}

/**

• 分析1：getNode(hash(key), key))

*/

final Node<K,V> getNode(int hash, Object key) {

Node<K,V>[] tab; Node<K,V> first, e; int n; K k;

// 1. 计算存放在数组table中的位置

if ((tab = table) != null && (n = tab.length) > 0 &&

(first = tab[(n - 1) & hash]) != null) {

// 4. 通过该函数，依次在数组、红黑树、链表中查找（通过equals（）判断）

// a. 先在数组中找，若存在，则直接返回

if (first.hash == hash && // always check first node

((k = first.key) == key || (key != null && key.equals(k))))

return first;

// b. 若数组中没有，则到红黑树中寻找

if ((e = first.next) != null) {

// 在树中get

if (first instanceof TreeNode)

return ((TreeNode<K,V>)first).getTreeNode(hash, key);

// c. 若红黑树中也没有，则通过遍历，到链表中寻找

do {

if (e.hash == hash &&

((k = e.key) == key || (key != null && key.equals(k))))

return e;

} while ((e = e.next) != null);

}

}

return null;

}

在JDK1.7及以前的版本中，HashMap里是没有红黑树的实现的，在JDK1.8中加入了红黑树是为了防止哈希表碰撞攻击，当链表链长度为8时，及时转成红黑树，提高map的效率

如果某个桶中的记录过大的话（当前是TREEIFY_THRESHOLD = 8），HashMap会动态的使用一个专门的treemap实现来替换掉它。这样做的结果会更好，是O(logn)，而不是糟糕的O(n)。它是如何工作的？

前面产生冲突的那些KEY对应的记录只是简单的追加到一个链表后面，这些记录只能通过遍历来进行查找。但是超过这个阈值后HashMap开始将列表升级成一个二叉树，使用哈希值作为树的分支变量，如果两个哈希值不等，但指向同一个桶的话，较大的那个会插入到右子树里。如果哈希值相等，HashMap希望key值最好是实现了Comparable接口的，这样它可以按照顺序来进行插入。这对HashMap的key来说并不是必须的，不过如果实现了当然最好。如果没有实现这个接口，在出现严重的哈希碰撞的时候，你就并别指望能获得性能提升了。

这个性能提升有什么用处？比方说恶意的程序，如果它知道我们用的是哈希算法，它可能会发送大量的请求，导致产生严重的哈希碰撞。然后不停的访问这些key就能显著的影响服务器的性能，这样就形成了一次拒绝服务攻击（DoS）。JDK 8中从O(n)到O(logn)的飞跃，可以有效地防止类似的攻击，同时也让HashMap性能的可预测性稍微增强了一些

/**

• 源码分析：resize(2 * table.length)

• 作用：当容量不足时（容量 > 阈值），则扩容（扩到2倍）

*/

void resize(int newCapacity) {

// 1. 保存旧数组（old table）

Entry[] oldTable = table;

// 2. 保存旧容量（old capacity ），即数组长度

int oldCapacity = oldTable.length;

// 3. 若旧容量已经是系统默认最大容量了，那么将阈值设置成整型的最大值，退出

if (oldCapacity == MAXIMUM_CAPACITY) {

threshold = Integer.MAX_VALUE;

最后的话

无论是哪家公司，都很重视Spring框架技术，重视基础，所以千万别小看任何知识。面试是一个双向选择的过程，不要抱着畏惧的心态去面试，不利于自己的发挥。
同时看中的应该不止薪资，还要看你是不是真的喜欢这家公司，好了希望这篇文章对大家有帮助！

部分截图：

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

这个性能提升有什么用处？比方说恶意的程序，如果它知道我们用的是哈希算法，它可能会发送大量的请求，导致产生严重的哈希碰撞。然后不停的访问这些key就能显著的影响服务器的性能，这样就形成了一次拒绝服务攻击（DoS）。JDK 8中从O(n)到O(logn)的飞跃，可以有效地防止类似的攻击，同时也让HashMap性能的可预测性稍微增强了一些

/**

• 源码分析：resize(2 * table.length)

• 作用：当容量不足时（容量 > 阈值），则扩容（扩到2倍）

*/

void resize(int newCapacity) {

// 1. 保存旧数组（old table）

Entry[] oldTable = table;

// 2. 保存旧容量（old capacity ），即数组长度

int oldCapacity = oldTable.length;

// 3. 若旧容量已经是系统默认最大容量了，那么将阈值设置成整型的最大值，退出

if (oldCapacity == MAXIMUM_CAPACITY) {

threshold = Integer.MAX_VALUE;

最后的话

无论是哪家公司，都很重视Spring框架技术，重视基础，所以千万别小看任何知识。面试是一个双向选择的过程，不要抱着畏惧的心态去面试，不利于自己的发挥。
同时看中的应该不止薪资，还要看你是不是真的喜欢这家公司，好了希望这篇文章对大家有帮助！

部分截图：
[外链图片转存中…(img-kLU3hoza-1715680177893)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取