本来今天想要重新整理一些hashMap的源码阅读解析文章的相关内容的，后面发现网上关于HashMap的源码解析已经有很多专业的分析了，在看了一遍源码之后，我就直接整理一下HashMap相关的一些热门面试题的答案吧。
在回答以下的面试题之前，还是希望对HashMap有以下的一些很基础性的认识。
- HashMap 允许Key、Value 同时为空
- 线程不安全
- HashMap是使用一个Node
4.进行pop时，如果该索引中存储结构为红黑树，其存储长度<=6，又会转化为链表的数据结构存储。 - hashMap数组的初始化之后长度为16.
- 负载因子，默认为0.75，也可以自己设置。是时间和空间之间的权衡，后面会详细说，这里需要知道，如果我们数组初始化长度为12，通过16负载因子的值得到12，当我们数组的长度超过12时，就需要进行扩容，每次扩容都是2倍扩容。
面试的问题总结:
从以下几点思路去入手分析:
size必须是2的整数次方原因
这个根据我有去看源码的思路的理解是这样的，在扩容时，每次都是new一个新的原来两倍的数组长度大小的node
在put的时候，每一个key，都会对应到一个桶里面，通过index = hash & (n-1)计算桶的索引。设原来的数组为table，负载因子为默认的0.75，长度n为16.则当里面的数据量大于12时，需要进行扩容。就会新建一个长度为16*2的数组为newTab。然后就会开始把原来数组tables里面的数据搬移到newTab，假设tables的第i个索引，通过索引的计算公式: hash & n（n为数组长度） ,对比新旧数组会发现一个规律，当我们把tabsles[i]的node迁到newTab时，里面的node数据要么在原来的i位置不变，要么就在i+n的位置，所以在put时这样处理把，根据该公式的值，把tables的数据拆分成两个链表L1以及L2，执行一次tables[i]下面的元素遍历，令newtab[i]=l1,newtab[i+n]=l2,这样就会完成tables[i]位置上面所有node的迁移了/refresh，这就是为什么设置容量为什么要为2的整数次幂带来的方便之处。resize的逻辑就是上面讲的那样。将table[i]处的Node拆分为两个链表，这两个链表再放到newtab[i]和newtab[i+n]位置
get方法的流程
内部会执行一个getNode方法判断的，入参是传入key的hash计算后的一个整数类型hash以及key。内部流程如下:
- 根据 (n-1) & hash的算法得到桶的索引(这个桶要详细解释的话，就是hashMap里面存放数据的table数组的某一个索引里面的包含的数据结构，初始化是有16个桶)，获取出的该桶里面的node。
- 匹配该node值是都是要找的key，如果是则直接返回。
3.否则，先判断node是否为TreeNode，也就是红黑树类型的node，如果是，则调用红黑树的getTreeNode去获取里面的值。
4.如果不是，执行链表查找，直到找到。
附上get(key)源码
public V get(Object key) {
Node e;
//hash：这个函数上面分析过了。返回key混淆后的hashCode
//注意getNode返回的类型是Node：当返回值为null时表示map中没有对应的key，注意区分value为
//null：如果key对应的value为null的话，体现在getNode的返回值e.value为null，此时返回值也是
//null，也就是HashMap的get函数不能判断map中是否有对应的key：get返回值为null时，可能不包
//含该key，也可能该key的value为null！那么如何判断map中是否包含某个key呢？见下面contains
//函数分析
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node getNode(int hash, Object key) {
Node[] tab; Node first, e; int n; K k;
//(n-1)&hash：当前key可能在的桶索引，put操作时也是将Node存放在index=(n-1)&hash位置
//主要逻辑：如果table[index]处节点的key就是要找的key则直接返回该节点；
//否则：如果在table[index]位置进行搜索，搜索是否存在目标key的Node：这里的搜索又分两种：
//链表搜索和红黑树搜索，具体红黑树的查找就不展开了，红黑树是一种弱平衡(相对于AVL)BST，
//红黑树查找、删除、插入等操作都能够保证在O(lon(n))时间复杂度内完成，红黑树原理不在本文
//范围内，但是大家要知道红黑树的各种操作是可以实现的，简单点可以把红黑树理解为BST，
//BST的查找、插入、删除等操作的实现在之前的博客中有java实现代码，实际上红黑树就是一种平
//衡的BST
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
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)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;//没找到，返回null
}
put方法流程
具体流程如下: 内部会执行一个putVal的方法，参数分别为( hash(key) , key , value , onlyIfAbsent,evict).会稍微复杂一点:
1.如果hashMap里面还未初始化，则初始化resize();
- 如果通过索引定位算法 (n-1) & hash 找到的桶为null，则直接构建一个node，set进去。
- 如果定位到的tabls[index]有元素了，先判断该元素key是否与存入的key相等，享的则set进去，否则判断是否为红黑树类型，使用红黑树的方式put进去putTreeVal。
4.以上都不是，则在该桶的位置开始遍历链表，直到链表的末尾，查找是否存在该key，构建node。
5.判断遍历的次数，如果大于等于8个，则执行是否进行转为红黑树结构存储的判断。 - 判断当前的key是否已存在，存在则更新key，并且有一个钩子函数，未实现，然后会返回旧的key的value值。
7.如果是第一次插入，则会执行到failfast机制，不会返回已存在的值，此时也已经put进去了。
8.判断当前的hashMap里面的数量是否大于负载因子计算后的值，需要进行扩容。 - return null
见源码如下:
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node[] tab; Node p; int n, i;
//上面提到过HashMap是懒加载，所有put的时候要先检查table数组是否已经初始化了，
//没有初始化得先初始化table数组，保证table数组一定初始化了
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;//这个函数后面有resize函数分析
//到这里表示table数组一定初始化了
//与上面get函数相同，指定key的Node，put在table数组的i=(n-1)&hash下标位置，get的时候
//也是从table数组的该位置搜索
if ((p = tab[i = (n - 1) & hash]) == null)
//如果i位置还没有存储元素，则把当前的key，value封装为Node，存储在table[i]位置
tab[i] = newNode(hash, key, value, null);
else {
//如果table[i]位置已经有元素了，则接下来执行的是：
//首先判断链表或者二叉树中时候已经存在key的键值对，存在的话就更新它的value
//不存在的话把当前的key，value插入到链表的末尾或者插入到红黑树中
//如果链表或者红黑树中已经存在Node.key等于key，则e指向该Node，即
//e指向一个Node：该Node的key属性与put时传入的key参数相等的那个Node，后面会更新e.value
Node e; K k;
//为什么get和put先判断p.hash==hash,下面的if条件中去掉hash的比较也可以逻辑也正确？
//因为hash的比较是两个整数的比较，比较的代价相对较小，key是泛型，对象的比较比整数比较
//代价大，所以先比较hash，hash相等在比较key
if (p.hash == hash &&//
((k = p.key) == key || (key != null && key.equals(k))))
e = p;//e指向一个Node：该Node的key属性与put时传入的key参数相等的那个Node
else if (p instanceof TreeNode)
//红黑树的插入操作，如果已经存在该key的TreeNode，则返回该TreeNode，否则返回null
e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
else {
//table[i]处存放的是链表，接下来和TreeNode类似
//在遍历链表过程中先判断是key先前是否存在，如果存在则e指向该Node
//否则将该Node插入到链表末尾，插入后判断链表长度是否>=8，是的话要进行额外操作
//binCountt最后的值是链表的长度
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
//遍历到了链表最后一个元素,接下来执行链表的插入操作，先封装为Node再插入
//p指向的是链表最后一个节点，将待插入的Node置为p.next，就完成了单链表的插入
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
//TREEIFY_THRESHOLD值是8， binCount>=7,然后又插入了一个新节点，
//链表长度>=8，这时要么进行扩容操作，要么把链表结构转为红黑树结构
//我们接下会分析treeifyBin的源码实现
treeifyBin(tab, hash);
break;
}
//当p不是指向链表末尾的时候：先判断p.key是否等于key，等于的话表示当前key
//已经存在了，令e指向p，停止遍历，最后会更新e的value；
//不等的话准备下次遍历，令p=p.next，即p=e
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
//表示当前的key之前已经存在了，并且上面的逻辑保证:e.key一定等于key
//这是更新e.value就好
V oldValue = e.value;//保存oldvalue
//onlyIfAbsent默是false，evict为true
//onlyIfAbsent为true表示如果之前已经存在key这个键值对了，那么后面在put这个key
//时，忽略这个操作，不更新先前的value，这里连接就好
if (!onlyIfAbsent || oldValue == null)
e.value = value;//更新e.value
//这个函数的默认实现是“空”，即这个函数默认什么操作都不执行，那为什么要有它呢？
//这是个hook/钩子函数，主要要在LinkedHashMap中，LinkedHashMap重写了这个函数
//后面讲解LinkedHashMap时会详细讲解
afterNodeAccess(e);
return oldValue;//返回旧的value
}
}
//如果是第一次插入key这个键，就会执行到这里
++modCount;//failFast机制
//size保存的是当前HashMap中保存了多少个键值对，HashMap的size方法就是直接返回size
//之前说过，threshold保存的是当前table数组长度*loadfactor，如果table数组中存储的
//Node数量大于threshold，这时候会进行扩容，即将table数组的容量翻倍。后面会详细讲解
//resize方法
if (++size > threshold)
resize();
//这也是一个hook函数，作用和afterNodeAccess一样
afterNodeInsertion(evict);
return null;
}
//将链表转换为红黑树结构，在链表的插入操作后调用
/**
* Replaces all linked nodes in bin at index for given hash unless
* table is too small, in which case resizes instead.
*/
final void treeifyBin(Node[] tab, int hash) {
int n, index; Node e;
//MIN_TREEIFY_CAPACITY值是64,也就是当链表长度>8的时候，有两种情况：
//如果table数组的长度<64,此时进行扩容操作
//如果table数组的长度>64，此时进行链表转红黑树结构的操作
//具体转细节在面试中几乎没有问的，这里不细讲了，
//大部同学认为链表长度>8一定会转换成红黑树，这是不对的！！！
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode hd = null, tl = null;
do {
TreeNode 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);
}
}
resize方法
该方法在初始化以及put的时候，需要扩容时这两种情况下，会执行该方法。
先判断是否超过最大容量，此时会把扩容临界点改为Integer的最大值，正常扩容的话会翻倍，使用位运算去扩容，并重新计算扩容后的最大容量，扩容临界值threshold也会*2
如果不扩容，该值为空，会执行初始化。
最后是对扩容时的处理，会新建一个容量为原来容量2倍的node数组，把原数组同索引下的同一个桶中，不管是红黑树还是链表结构，都按照(hash & N（该桶的数量）)得出的值，如果该值为0，则放在链表L1(loTail)，否则L2（hiTail）上.迁移时，把L1数据放到table[i]上面，L2放到table[i+n(扩容前的长度)]上。
见源码:
final Node[] resize() {
Node[] 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;
}
//正常扩容：newCap = oldCap << 1
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//容量翻倍，扩容后的threshold自然也是*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
//table数组初始化的时候会进入到这里
newCap = DEFAULT_INITIAL_CAPACITY;//默认容量
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//threshold
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;//更新threshold
@SuppressWarnings({"rawtypes","unchecked"})
Node[] newTab = (Node[])new Node[newCap];//扩容后的新数组
table = newTab;//执行容量翻倍的新数组
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {//之后完成oldTab中Node迁移到table中去
Node e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)//j这个桶位置只有一个元素，直接rehash到table数组
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
//如果是红黑树：也是将红黑树拆分为两个链表，这里主要看链表的拆分，两者逻辑一样
((TreeNode)e).split(this, newTab, j, oldCap);
else { // preserve order
//链表的拆分
Node loHead = null, loTail = null;//第一个链表l1
Node hiHead = null, hiTail = null;//第二个链表l2
Node next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {//rehash到table[j]位置
//将当前node连接到l1上
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
//将当前node连接到l2上
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
//l1放到table[j]位置
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
//l1放到table[j+oldCap]位置
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
影响HashMap的性能因素（key的hashCode函数实现、loadFactor、初始容量）
key的hashCode函数实现，主要是因为该实现，可以将key的hashCode的高16位的随机性与低16位进行异或运算，增强hash的随机性减少hash&(n-1)的 随机性(这个是计算桶的索引的算法)，即减小hash冲突，提高HashMap的性能。
看源码：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
loadFactor: 负载因子，决定桶的利用率。当size==桶的数量DEFAULT_LOAD_FACTOR的时候，这时HashMap要进行扩容操作，也就是桶不能装满。DEFAULT_LOAD_FACTOR是衡量桶的利率:DEFAULT_LOAD_FACTOR较小时（桶的利用率较小）,这时浪费的空间较多（因为只能存储桶的数量DEFAULT_LOAD_FACTOR个元素，超过了就要进行扩容）,这种情况下往HashMap中put元素时发生冲突的概率也很小，所谓冲突指的是：多个元素被put到了同一个桶 中; 冲突小时（可以认为一个桶中只有一个元素）put、get等HashMap的操作代价就很低，可以认为是O(1);桶的利用率较大的时候(DEFAULT_LOAD_FACTOR很大，注意可以大于1，因为冲突的元素是使用链表或者 红黑树连接起来的)空间利用率较高
HashMap key的hash值计算方法以及原因（见上面hash函数的分析）
HashMap内部存储结构：Node数组+链表或红黑树
table[i]位置的链表什么时候会转变成红黑树
table[i]位置的链表里面的node数量大于8并且整体容量大于64时，会转换为红黑树存储结构
HashMap主要成员属性：threshold(扩容的临界值)、loadFactor(负载因子)、HashMap的懒加载
HashMap的get方法能否判断某个元素是否在map中
如果java程序对key不存在和存在但是值为null，判断是一致的，那么可以使用该get判断，不然还是使用containskey();
HashMap线程安全吗，哪些环节最有可能出问题，为什么？
线程不安全，多线程情况下会导致hashmap链表闭环， 一旦进入了闭环get数据，程序就会进入死循环，所以导致HashMap是非线程安全的。
HashMap中的hook函数（可以链接到LinkedHashMap讲解，这可作为HashMap的延伸知识，增加面试官对你的印象）
摘自以下博客:
https://www.jianshu.com/p/8e668a010f43
线程不安全的hashMap: https://blog.csdn.net/V_Axis/article/details/78604505