最新从JDK源码学习Hashmap,这样说我就懂了，高级java软件工程师面试题

最后

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

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

【附】架构书籍

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

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

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

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

else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//否则当前节点为链表
else {
//遍历链表(因为我们之前已经知道每个node节点都存储了下一个节点的地址，所以P.next变量即代表相对于当前node的下一个node，那么遍历到一个链表的尾部放入新的节点即可)
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 //放入后判断，如果当前hash表的长度>=7，则将当前hash位置处转为红黑树表示从而替换链表表示
treeifyBin(tab, hash);
break;
}
//如果遍历过程中发现链表中存在相同的key则break退出
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e; //否则更新p节点为e，从而实现循环遍历链表
}
}
//如果保存冲突节点的e变量不为null，则取冲突的值，根据onlyIfAbsent没有设置或者当前value为null，都将
if (e != null) { // existing mapping for key
V oldValue = e.value; //取到冲突节点的value
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount; //hashmap修改次数，防止多线程冲突的
if (++size > threshold) //判断当前node节点的多少有没有到扩容的阈值
resize();
afterNodeInsertion(evict);
return null;
}

所以整个put的流程为：

①.首先根据要放入的key计算hash，然后根据hash获取table中的放入位置，如果当前table为空，则进行初始化

②.判断放入位置是否为空，为空则直接放入，否则判断是否为红黑树节点，不是则为链表，则遍历链表查找是否存在相同的key，没找到则放入链表尾部并判断是否需要转为红黑树(TREEIFY_THRESHOLD)

③.若查找链表找到相同key则替换，放入后要判断node节点数是否超过threshold，判断是否需要resize

resize方法，扩充当前容量：

final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table; //保存旧的hash表
int oldCap = (oldTab == null) ? 0 : oldTab.length; //判断hash表的长度，若是第一次初始化则为0
int oldThr = threshold; //取旧的阈值
int newCap, newThr = 0; //定义新的长度和阈值
if (oldCap > 0) { //如果之前长度大于零
if (oldCap >= MAXIMUM_CAPACITY) { //如果之前的长度大于等于2的30次
threshold = Integer.MAX_VALUE; //则将node节点阈值设置为2的31次-1
return oldTab; //返回旧的hash表,不再扩容
}
//否则满足扩容条件，进行扩容
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && //如果旧的容量扩大一倍小于2的30次并且旧的容量大于默认的初始化容量大小16，阈值也变为原来的2倍
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold 则容量扩大一倍
}
//如果旧的容量为0，但是旧的阈值大于零，则可能是初始化hashmap时指定了容量，则直接将新的容量设置为旧的阈值
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//对于没有设置初始容量的情况
else { // zero initial threshold signifies using defaults //如果是第一次初始化，则设置容量为16，阈值为160.75=12,即hashmap可以放12个node节点
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//如果新的阈值为0，则进行修正，令新的阈值为新的hash表容量长负载因子
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//设置完新的容量和新的阈值后，则开始进项node节点元素转移
threshold = newThr; //先将新生成的阈值赋值给成员变量threshold
@SuppressWarnings({“rawtypes”,“unchecked”})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; //然后声明一个新的节点数组，容量即为扩充后的大小
table = newTab; //替换成员标量table为新表
if (oldTab != null) { //遍历旧的容量大小，取其每个node节点
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) { //如果该节点不为null
oldTab[j] = null; //则让旧表的该位置为null，进行垃圾回收
if (e.next == null) //如果当前遍历的节点下一个为null，说明为尾节点(单个node节点，无链表，无红黑树)
newTab[e.hash & (newCap - 1)] = e; //则直接将该节点放到新的hash表中
//如果下一个节点不为null，则判断当前节点是否是红黑树节点,若是，则将新标的该节点转为红黑树节点
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//否则为单链表节点，则遍历当前链中的节点决定要放入新hash表的位置
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;
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;
}

这里设计很妙，原来的容量为2的次方，则只有1位为1，原来的下标是容量-1，则新增的一位bit，决定了节点hash新增的一位为1还是为0，来决定其存放位置，其也为随机的，从而均匀地将节点放到新的hash表中，新增一位为0则放到低位中，即索引值不变，新增一位为1，则放到高位中，这样原本在一条链中的节点就能够分布到两条链上，也减少了搜索的开销

jdk1.7和1.8的Hashmap区别

1.jdk1.7中发生hash冲突新节点采用头插法，1.8采用的为尾插法

2.1.7采用数组+链表，1.8采用的是数组+链表+红黑树

3.1.7在插入数据之前扩容，而1.8插入数据成功之后扩容

总结

1.在算key的hash时将key的hashcode和与hashcode的高16位做异或降低hash冲突概率

2.HashMap 的 bucket (数组)大小一定是2的n次方，便于后面等效取模以及resize时定节点分布(low或者high)

3.HashMap 在 put 的元素数量大于 Capacity * LoadFactor（默认16 * 0.75）=12 之后会进行扩容，负载因子大于0.75则会减小空间开销，

4.影响hashmap性能的两个参数就是负载因子和初始容量，扩容影响性能，因此最好能提前根据负载因此估算hashmap大小，扩容实际上是将当前node节点放入一个新的node数组

5.tab[i = (n - 1) & hash] 实际上用与运算代替取模操作，性能更好，n即为容量大小，n为2的次方，则n-1则其二进制位为全1，从而代替模运算，e.hash & oldCap 用与运算决定hash增加的一位为0或者为1

关于负载因子设置：

负载因子的大小决定了HashMap的数据密度。
负载因子越大密度越大，发生碰撞的几率越高，数组中的链表越容易长,造成查询或插入时的比较次数增多，性能会下降。
负载因子越小，就越容易触发扩容，数据密度也越小，意味着发生碰撞的几率越小，数组中的链表也就越短，查询和插入时比较的次数也越小，性能会更高。但是会浪费一定的内容空间。而且经常扩容也会影响性能，建议初始化预设大一点的空间。
按照其他语言的参考及研究经验，会考虑将负载因子设置为0.7~0.75，此时平均检索长度接近于常数

最后的话

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

部分截图：

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

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

一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)收录**

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