（Java）笔记篇---HashMap底层原理解析及HashMap常考面试题(1)

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

//HashMap将其底层链表中的节点封装为静态内部类

//节点中带有key，value键值对以及key所对应的哈希值

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; }

//重写Object类中hashcode()方法

public final int hashCode() {

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

}

public final V setValue(V newValue) {

V oldValue = value;

value = newValue;

return oldValue;

}

//重写Object类中equals方法

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;

}

}

五. 哈希函数

=======

将key转化为一个整型数字，再用这个数字进行除留余数法计算桶的位置

解析：

1. 如果key为null，返回0号桶。

2. 如果key不为null，返回key所对应的哈希码，如果key为自定义类型，必须重写Object类中的hashcode()方法。

3. ( h = key . hashCode() ) ^ ( h >>> 16 ),是为了让高16bit不变，低16bit与高16bit进行异或，主要用于当hashmap数组比较小的时候所有bit都参与运算，目的是减小碰撞。

4. 获取到哈希地址后，计算桶号的方式为：index = (table.length - 1) & hash。

5. 通过除留余数法方式获得桶号，因为hash表的大小始终为2的n次幂，因此可以将取模转为位运算，提高效率，这也是为什么要按照2倍方式扩容的一个原因。

这里画图来说明一下原因：

**总结：**通过上述方式可知，实际上hashcode的很多位是用不上的，因此在hashMap的hash函数中，才使用了移位运算，只取了前16位来做映射，另一方面&运算比取模效率更高。

六. 扩容

=====

每次都是将cap扩大到与cap最近的2的n次幂，int n = cap - 1;是为了防止cap已经是2的幂次方，如果cap已经是2的幂次方，则执行完后面的几条无符号右移操作之后，返回的capacity将是这个cap的2倍。

假设现在cap的初始值为10，具体方式如下：

七. HashMap中常用的方法

================

1. 构造方法

---

// 构造方法一：带有初始容量的构造，负载因子使用默认值0.75

public HashMap(int initialCapacity) {

this(initialCapacity, DEFAULT_LOAD_FACTOR);

}

// 构造方法二：

public HashMap() {

this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted

}

// 构造方法一：带有初始容量和初始负载因子的构造

public HashMap(int initialCapacity, float loadFactor) {

// 如果容量小于0，抛出非法参数异常

if (initialCapacity < 0)

throw new IllegalArgumentException("Illegal initial capacity: " +

initialCapacity);

// 如果初始容量大于最大值，用2^30代替

if (initialCapacity > MAXIMUM_CAPACITY)

initialCapacity = MAXIMUM_CAPACITY;

// 检测负载因子是否非法，如果负载因子小于0，或者负载因子不是浮点数，抛出非法参数异常

if (loadFactor <= 0 || Float.isNaN(loadFactor))

throw new IllegalArgumentException("Illegal load factor: " +

loadFactor);

// 给负载因子和容量赋值，并将容量提升到2的整数次幂

// 注意：构造函数中并没有给

this.loadFactor = loadFactor;

this.threshold = tableSizeFor(initialCapacity);

}

/*

注意：

不同于Java7中的构造方法，Java8对于数组table的初始化，并没有直接放在构造器中完成，而是将table数组的构

造延迟到了resize中完成

*/

2. 查找，根据key获取value

---

/*

1. 通过key计算出其哈希地址，然后借助哈希地址在哈希桶中找到与key对应的节点

2. 如果节点为null，返回null，说明HashMap中节点是可以为空的

3. 如果节点不为空，返回该节点中的value

*/

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;

// 1. 先检测哈希桶是否为空

// 2. 检测哈希桶的个数是否大于零，如果桶不空，桶的个数肯定不为0

// 3. n-1&hash–>计算桶号

// 4. 当前桶是否为空桶

// 如果1 2 3 4均不成立，说明当前桶中有节点，拿到当前桶中第一个节点

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

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

// 如果节点的哈希值与key的哈希值相等，然后再检测key是否相等

// 如果相等，则返回该节点

// 此处也进一步证明了：HashMap必须要重写hashCode和equals方法

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

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

return first;

// 如果第一个节点后还有节点，检测first是否为treeNode类型的

// 因为如果哈希桶中某条链节点大于8个，为了提高性能，HashMap会将链表替换为红黑树

// 此时再红黑树中找与key对应的节点

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;

}

3. 检测key是否存在

---

/*

1. 先通过getNode()获取与key对应的节点

2. 如果节点不为空，说明存在返回true，否则返回false

3. 时间复杂度：平均为O(1)，如果当天key所对应的桶中挂接的链表则顺序查找，挂接的是红黑树按照红黑树性质找

*/

public boolean containsKey(Object key) {

return getNode(hash(key), key) != null;

}

4. 插入

---

/*

1. 先使用key借助hash函数计算key的哈希地址

2. 将key-value键值对，结合计算出的hash地址插入到哈希桶中

3. 从以下代码中可以看到，HashMap在插入时，并没有处理线程安全问题，因此HashMap不是线程安全的

4. 红黑树优化链表过长是java8新引进，是基于性能的考虑，在冲突大时，红黑树算法会比链表综合表现更好

*/

public V put(K key, V value) {

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;

// 1. 桶如果是空的，则进行扩容

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

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

// 2. (n-1)&hash–>计算桶号，如果当前桶中没有节点，直接插入

// p来记录桶中的第一个节点

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

tab[i] = newNode(hash, key, value, null);

else {

Node<K,V> e; K k;

// 3. 如果key已经是和桶中第一个节点相等，不进行插入

if (p.hash == hash &&

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

e = p;

else if (p instanceof TreeNode) // 4. 如果该桶中挂接的是红黑树，向红黑树中插入

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

else {

// 5. key不同，也不是红黑树，说明当前桶中挂的是一个链表

// a. 在当前链表中找key

// b. 如果找到，则不插入

// c. 如果没有找到，先构建新节点，然后将该节点尾插到链表中

// d. 检测bitCount的计数，binCount记录的是在未插入新节点前原链表的节点个数

// e. 新节点插入后，链表长度是否超过TREEIFY_THRESHOLD，如果超过将链表转换为红黑树

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

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

// p已经是最后一个节点，说明在链表中未找到key对应的节点

// 进行尾插

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

if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st

treeifyBin(tab, hash); // 将链表转化为红黑树

break;

}

// 如果key已经存在，跳出循环

if (e.hash == hash &&

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

break;

p = e;

}

}

// 如果key已经存在，将key所对节点中的value替换为参数指定value，返回旧value

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;

}

/*

注意：afterNodeAccess和afterNodeInsertion主要是LinkedHashMap实现的，HashMap中给出了该方法，但是

并没有实现

*/

// Callbacks to allow LinkedHashMap post-actions

// 访问、插入、删除节点之后进行一些处理，

// LinkedHashMap正是通过重写这三个方法来保证链表的插入、删除的有序性

void afterNodeAccess(Node<K,V> p) { }

void afterNodeInsertion(boolean evict) { }

void afterNodeRemoval(Node<K,V> p) { }

/*

LinkedHashMap: 继承了HashMap，在LinkedHashMap中会对以上方法进行重写，以保证存入到LinkedHashMap中

的key是有序的，注意这里的有序是不自然序列，指的是插入元素的先后次序

LinkedHashMap底层的哈希桶使用的是双向链表

*/

5. 删除

---

写在最后

可能有人会问我为什么愿意去花时间帮助大家实现求职梦想，因为我一直坚信时间是可以复制的。我牺牲了自己的大概十个小时写了这片文章，换来的是成千上万的求职者节约几天甚至几周时间浪费在无用的资源上。

上面的这些（算法与数据结构）+（Java多线程学习手册）+（计算机网络顶级教程）等学习资源

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
是不自然序列，指的是插入元素的先后次序

LinkedHashMap底层的哈希桶使用的是双向链表

*/

5. 删除

---

写在最后

可能有人会问我为什么愿意去花时间帮助大家实现求职梦想，因为我一直坚信时间是可以复制的。我牺牲了自己的大概十个小时写了这片文章，换来的是成千上万的求职者节约几天甚至几周时间浪费在无用的资源上。

[外链图片转存中…(img-qDAfS5Z9-1713193313749)]

[外链图片转存中…(img-7ujdYj7a-1713193313750)]

上面的这些（算法与数据结构）+（Java多线程学习手册）+（计算机网络顶级教程）等学习资源

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-oCFgSHdX-1713193313750)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！