HashMap
一、HashMap简介
HashMap基于哈希表的Map接口实现。是以key-value存储形式存在。线程不安全,也就是说多个线程同时对HashMap进行增删改操作时，不能保证数据时一致的。key和value都可以为null，无序存放。
JDK1.8之前由数组+链表组成，数组是HashMap主体，链表则主要是为了解决哈希冲突（两个对象调用的hashCode方法计算的哈希码值一致导致计算的数组索引值相同）而存在的（“拉链法”解决冲突），JDK1.8之后，当链表长度大于阈值（或者红黑树的边界值，默认为8）并且当前数组的长度大于64时，此时此索引位置上的所有数据改为使用红黑树存储。
注意：为了提高效率，将链表转换为红黑树前会判断，即使链表阈值大于8，但是数组长度小于64，此时并不会将链表变为红黑树，而是选择进行数组扩容。
Java为数据结构中映射定义了一个接口java.util.Map，接口主要有四个常用的实现类，分别是HashMap、Hashtable、LinkedHashMap和TreeMap，类继承关系如下图所示：
对其中的HashMap进行介绍：
它根据键的hashCode值进行数据存储，大多数情况下可以直接定位到它的值，因而具有很快的访问速度，但数据的存储却是无序的。HashMap最多只允许一条记录的键为null,运行允许多条记录值为null。HashMap非线程安全，如果需要满足线程安全，可以用Collections的synchronizedMap方法使HashMap具有线程安全的能力，或者使用ConcurrentHashMap.
其余学习到再做介绍。
参考：https://zhuanlan.zhihu.com/p/21673805
HashMap集合底层的数据结构
JDK1.8之前，数组+链表，创建HashMap对象，会创建一个长度为Entry[] table来存储键值对信息。
JDK1.8之后，数组+链表+红黑树，创建HashMap对象，不是在构造方法中创建了，而是在第一次调用put方法时创建，创建Node[] table用于存储键值对信息。
面试常问：哈希表底层采用何种算法计算哈希值？还有哪些方法可以计算哈希值？
底层采用key的hashCode()的值结合数组长度进行无符号右移（>>>）,按位异或（^）计算hash值，按位与（&）计算索引。
static final int hash(Object key) { //jdk1.8 & jdk1.7
int h;
// h = key.hashCode() 为第一步 取hashCode值
// h ^ (h >>> 16) 为第二步 高位参与运算
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
//返回索引值
static int indexFor(int hash, int length) { //jdk1.7的源码，jdk1.8没有这个方法，但是实现原理一样的
return h & (length-1); //第三步 取模运算
}
这里的Hash算法本质上就是三步：取key的hashCode值、高位运算、取模运算。
关键点介绍：
hashCode（）：Object类的一个本地方法，用于对象的存储和查找的快捷性，在HashMap中发挥重要作用。
返回的是对象存储物理地址的一个映射地址(并不一定等于这个地址)，这个地址有什么用呢？
通过这个地址可以定位到它应该存放的物理位置上，如果这个这个位置上没有元素，则直接插入到此位置；如果位置上有元素，Object中equals()进行判断是不是用一个对象，如果是则不插入，如果不是，则替换这个位置的值。
hashCode()与String 的equals()之间的关系：
如果x.equals(y)返回“true”，那么x和y的hashCode()必须相等。
如果x.equals(y)返回“false”，那么x和y的hashCode()有可能相等，也有可能不等，例如：
System.out.println("重地".hashCode());//1179395不唯一
System.out.println("通话".hashCode());//1179395
计算公式：s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1] //不展开
采用以上的hashCode()的优越性？
例如有四个桶来装对象，每个桶装的对象不能重复，A,B,C,D，Person类new出的对象可分别放任何一个桶中，如何判断放进去对象重复？想通过hashCode定位放的桶，然后equals判断是否是同一个对象，考虑要不要放进去，这样比较的就是一个桶中的数据。
倘若没有这个hashCode则需要一个一个桶去比较，对象进行比较是不是同一个对象，效率极低。所以一般要在重新equals方法的同时也重写hashCode.
补充：本地方法是什么？
是由其他语言（如C、C++ 或其他汇编语言）编写，编译成和处理器相关的代码。本地方法保存在动态连接库中，格式是各个平台专用的，运行中的java程序调用本地方法时，虚拟机装载包含这个本地方法的动态库，并调用这个方法。
HashMap最为核心的put方法：
方法执行流程：
（1）put方法传入键值
（2）Node<K,V>[] table 是否为空 (JDK1.8),如果为空，则进行resize()扩容
（3）table 不为空，根据hash值+高位右移+异或+取模计算索引值。确定存放的位置。
（4）如果存放的位置为空，则直接插入，++size
（5）如果存放的位置不为空，通过重写Object的equals的方法进行遍历链表中是否存在相等的key
（6）若存在相等的，则直接覆盖value值
（7）否则判断链表的阈值是否>8 ,数组长度是否>64(满不满足生成红黑二叉树)，若满足，则将键值对插入红黑二叉树中
（8）如果不满足，则开始遍历链表插入，如果插入后链表长度 > 8且table长度 > 64,则转换称红黑树后插入
（9）倘若仍不满足红黑树，则遍历链表插入，遇到相同的key,覆盖value插入
源码解析：
HashMap：
// key --- value
public V put(K key, V value) {
/*
1.hash(key)：计算key的hash值
2.key
3.value
4.onlyIfAbsent:当键相同时不修改已存在的值
5.true：如果为false,那么数组就处于创建模式中，所以一般为true
*/
return putVal(hash(key), key, value, false, true);
}
其中 putVal(hash(key), key, value, false, true);
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//tab数组：存储键值对 p：当前插入的键值对
Node<K,V>[] tab; Node<K,V> p; int n, i;
//如果数组为空 ,则新建一个数组
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//计算出索引值，并赋值给当前p，并判断是否冲突，如果不冲突则开辟出一个Node空间存储键值对
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//如果冲突
else {
Node<K,V> e; K k;
//当前的节点p和要插入的节点key相等，就将p值赋给e,用于后面对节点e进行afterNodeAccess(e);
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//如果当前节点p是红黑树的头节点，则将节点插入到红黑树中
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//不是红黑树，则遍历链表。如果没找到和要插入节点相同的节点，则插入到链表的最后面，此时如果链表的阈值 >8 且数组的长度 > 64则转换成红黑树，break退出循环
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//链表长度大于8转换为红黑树进行处理
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相等的节点，将value赋值给它，并将e节点进行 afterNodeAccess(e);
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
//插入成功后判断实际存在的键值对数量size是否大于阈值threshold，如果大于则进行扩容
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
扩容 resize();
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//threshold = 初始容量 * 加载因子。也就是扩容的 门槛。相当于实际使用的容量
int oldThr = threshold;
int newCap, newThr = 0;
//
if (oldCap > 0) {
//如果超过了数组的最大值，则将阈值设置为最大值
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;扩容
return oldTab;
}
//如果没有超过则设置为原来的两倍 <<1
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
//旧的数组的阈值已经在使用
else if (oldThr > 0) // initial capacity was placed in threshold
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) {
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) {
// 把每个bucket都移动到新的buckets中
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)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // 链表优化重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;
}
HashMap核心get方法：
//注意：返回的是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;
//如果表不为空
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//table[i]首元素则返回first满足key与待查相等，则返回first
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 {
//满足key相等
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null); //遍历next结束
}
}
return null;
}
面试可能遇到的问题：
（1）为什么不直接使用hashCode计算hash值，还要经过右移16位且异或的操作？
答：如果一个key经过hashCode()得到
h = 1110 1010 1110 0011 1010 0101 0001 1110
table[]的默认长度是16，进行了h & (n-1) = h&15
1110 1010 1110 0011 1010 0101 0001 1110
&
0000 0000 0000 0000 0000 0000 0000 1111
=
0000 0000 0000 0000 0000 0000 0000 1110
无论高位是什么值，只有1110会被分配在一起(只有低位参与的运算)，哈希碰撞的概率将会变得很高。
而如果进行右移16位的异或操作
1110 1010 1110 0011 1010 0101 0001 1110 >>>16 (高位向低位移动10位，高位补0)
=
0000 0000 0000 0000 1110 1010 1110 0011
再进行异或操作（相异为1）
0000 0000 0000 0000 1110 1010 1110 0011
^
1110 1010 1110 0011 1010 0101 0001 1110
=
1110 1010 1110 0011 0100 1111 1111 1101
得到的数据再进行取模运算得到的索引值将大大减少了哈希碰撞的概率。
（2）Hash算法是如何实现的？
答：通过计算key的hashCode值，再将值进行高位右移16位后异或刚刚得到的hashCode值，即hash值。
（3）为什么是线程不安全？
答：因为多个线程同时操作HashMap，并进行put操作如果hash值相同，可能会遇到解决冲突，由于put方法里面没有加入同步锁synchronized机制，因此容易造成数据的不一致，类似addEntry()、resize()方法都不是同步的，因此HashMap是线程不安全。
（4）HashMap的数据结构是什么？
在JDK1.8之前HashMap是数组+链表的形式，
在JDK1.8包括之后是数组+链表+红黑树，当链表超过8且数组总量超过64才会转红黑树。
（5）HashMap是如何解决hash碰撞的？
答：HashMap采用采用 “拉链法” ，将hash值相同的元素放到同一个链表下面，还可以采用的方法：平方取中法，伪随机数法，取余法
（6）HashMap的put方法是怎么实现的？
答：上图⬆
（7）HashMap的get方法是怎么实现的？
- 将查询的key传入进行hash计算得到hash值
- 再通过tab[i = (n - 1) & hash]计算索引值定位到table[i]
- 判断首元素的key是否和待查的key == ，若是则直接返回节点
- 如果不是则开始遍历链表判断是否结构是红黑树，若是，则进行红黑树树的遍历
- 若不是，则开始遍历单链表，找到key == 就返回节点
（8）拉链法导致的链表过深问题为什么不用二叉查找树代替，而选择红黑树？为什么不一直使用红黑树？
答：选择红黑树是为了解决二叉查找树的缺陷，因为二叉查找树在特殊的情况下会变成一条线性结构，类似与单链表，造成二叉树出现不平衡现象，遍历查找的时候会很慢。引入红黑二叉树就是因为他是一个自平衡的二叉树，会自己调整到二叉树平衡这样就可以提高遍历和查找的效率
（8）默认加载因子为什么是0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
答：加载因子需要在时间和空间成本上寻求一种折衷。
加载因子: 是表示Hash表中元素的填满的程度。
加载因子越大,填满的元素越多,空间利用率越高，但冲突的机会加大了。
反之,加载因子越小,填满的元素越少,冲突的机会减小,但空间浪费多了。
冲突的机会越大,则查找的成本越高。反之,查找的成本越小。
（9）HashMap桶中链表转红黑树为什么选择数字8？
答：通过阅读源码发现：
Because TreeNodes are about twice the size of regular nodes, we use them only when bins contain enough nodes to warrant use (see TREEIFY_THRESHOLD). And when they become too small (due to removal or resizing) they are converted back to plain bins. In usages with well-distributed user hashCodes, tree bins are
rarely used. Ideally, under random hashCodes, the frequency of nodes in bins follows a Poisson distribution (http://en.wikipedia.org/wiki/Poisson_distribution) with a parameter of about 0.5 on average for the default resizing threshold of 0.75, although with a large variance because of resizing granularity. Ignoring variance, the expected occurrences of list size k are (exp(-pow(0.5, k) / factorial(k)). The first values are:
0: 0.60653066
1: 0.30326533
2: 0.07581633
3: 0.01263606
4: 0.00157952
5: 0.00015795
6: 0.00001316
7: 0.00000094
8: 0.00000006
more: less than 1 in ten million
简单的说就是按照泊松分布的计算公式计算出了放入桶中元素个数和概率的对照表，可以看到链表中元素个数为8时的概率已经非常小，再多的就更少了，所以原作者在选择链表元素个数时选择了8，是根据概率统计而选择的，这样就相当于在链表转红黑树之间取一个适中，也是为了提高效率而设定的。
（10）HashMap的resize()扩容机制？
答：当put进去元素后，table中的元素个数> table*loadFactor(默认加载因子0.75) ，那么数组就开始扩容，例如：table数组的默认大小是16，当put后的数组长度超过12 * 0.75 = 12时，数组开始扩容，扩容大小 = 原来的一倍，然后重新计算每个元素在数组中的位置。
（10）可以使用CocurrentHashMap来代替Hashtable吗？？