HashMap
HashMap 的重要性和面试问到的频率不言而喻，这篇文章我们就 HashMap 的原理和代码来进行分析。
什么是哈希表
讨论哈希表之前，我们先来把一些常用的数据结构的增删改查的性能比较一下。
数组：采用一段连续的存储单元来存储数据。对与指定下标的查找和插入，其时间复杂度为 O(1)，通过给定值查找，需要遍历数组，逐一比对，时间复杂度为 O(n)。对于删除操作，涉及到数组元素的移动，时间复杂度也为 O(n)。
线性链表：对于新增和删除操作，只需要更改引用即可，时间复杂度为 O(1)。查找操作需要遍历链表，时间复杂度为 O(n)。
二叉树：对于一颗相对平衡的有序二叉树，对其进行插入，查找，删除等操作，平均复杂度为 O(logn)。
哈希表：在不考虑哈希冲突的情况下，对哈希表中的数据进行添加，删除和查找等操作仅需要一次定位就可以完成，时间复杂度为 O(1)。哈希表是如何实现的那？
其实数据结构在物理存储层面只有两种：顺序存储结构和链式存储结构（像栈，队列，树，图等结构都是从逻辑结构中抽象的，映射到内存中，也是这两种形式）。哈希表的底层就是利用了数组，所以才能达到 O(1) 的时间复杂度。
哈希冲突：我们使用哈希表的时候，如果计算出来的地址相同怎么办？这就是哈希冲突。所以哈希函数的设计至关重要，好的哈希函数能够保证 计算简单和散列均匀分布。有了冲突怎么解决那？HashMap 底层数据结构是数组，每个数组节点里面放着链表，链表中的每个节点就是哈希表中的元素，在 JDK 1.8 中，当链表长度达到 8 时，链表会转化为红黑树，以便提高插入和查询效率。
概要
HashMap 是一个关联数组，哈希表。线程不安全，允许 key 为 null，value 为 null。底层数据结构是数组，每个数组节点里面放着链表，链表中的每个节点就是哈希表中的元素，在 JDK 1.8 中，当链表长度达到 8 时，链表会转化为红黑树，以便提高插入和查询效率。
代码分析
HashMap 的底层是数组，那么数组里面保存的是什么那？答案就是 Entry 键值对，key-value 键值对。1.8 改成了 Node 节点，原理相同。
//HashMap的主干数组，可以看到就是一个Entry数组，初始值为空数组{}，主干数组的长度一定是2的次幂，至于为什么这么做，后面会有详细分析。
transient Node<k,v>[] table;//存储（位桶）的数组</k,v>
Entry 类
//Node是单向链表，它实现了Map.Entry接口
static class Node<k,v> implements Map.Entry<k,v> {
final int hash;
final K key;
V value;
Node<k,v> next;
//构造函数Hash值 键 值 下一个节点
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;
}
//判断两个node是否相等,若key和value都相等，返回true。可以与自身比较为true
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;
}
所以 HashMap 的存储结构如下：
如果我们对 HashMap 进行操作时不包含链表，那么时间复杂度就是 O(1)，如果包含链表，时间复杂度就是 O
(n)。JDK 1.8 为了提高性能，在链表长度为 8 时，会将链表转换为红黑树，这时时间复杂度就是 O(logn)。
其他几个重要字段：
//实际存储的key-value键值对的个数
transient int size;
//阈值，当table == {}时，该值为初始容量（初始容量默认为16）；当table被填充了，也就是为table分配内存空间后，threshold一般为 capacity*loadFactory。HashMap在进行扩容时需要参考threshold，后面会详细谈到
int threshold;
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//负载因子，代表了table的填充度有多少，默认是0.75
final float loadFactor;
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//用于快速失败，由于HashMap非线程安全，在对HashMap进行迭代时，如果期间其他线程的参与导致HashMap的结构发生变化了（比如put，remove等操作），需要抛出异常ConcurrentModificationException
transient int modCount;
get 方法
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
* Implements Map.get and related methods
*
* @param hash hash for key
* @param key the key
* @return the node, or null if none
*/
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab;//Entry对象数组
Node<K,V> first,e; //在tab数组中经过散列的第一个位置
int n;
K k;
/*找到插入的第一个Node，方法是hash值和n-1相与，tab[(n - 1) & hash]*/
//也就是说在一条链上的hash值相同的
if ((tab = table) != null && (n = tab.length) > 0 &&(first = tab[(n - 1) & hash]) != null) {
/*检查第一个Node是不是要找的Node*/
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))//判断条件是hash值要相同，key值要相同
return first;
/*检查first后面的node*/
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
/*遍历后面的链表，找到key值和hash值都相同的Node*/
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
根据 key 计算出 hash 值，然后 hash&(n-1)得到在数组中存储的位置，通过遍历链表或者红黑树得到想要的元素，hash 相同，key 相同才满足。
put 方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* Implements Map.put and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to put
* @param onlyIfAbsent if true, don't change existing value
* @param evict if false, the table is in creation mode.
* @return previous value, or null if none
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab;
Node<K,V> p;
int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
/*如果table的在（n-1）&hash的值是空，就新建一个节点插入在该位置*/
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
/*表示有冲突,开始处理冲突*/
else {
Node<K,V> e;
K k;
/*检查第一个Node，p是不是要找的值*/
if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
/*指针为空就挂在后面*/
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//如果冲突的节点数已经达到8个，看是否需要改变冲突节点的存储结构，
//treeifyBin首先判断当前hashMap的长度，如果不足64，只进行
//resize，扩容table，如果达到64，那么将冲突的存储结构为红黑树
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值*/
if (e != null) { // existing mapping for key，就是key的Value存在
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;//返回存在的Value值
}
}
++modCount;
/*如果当前大小大于门限，门限原本是初始容量*0.75*/
if (++size > threshold)
resize();//扩容两倍
afterNodeInsertion(evict);
return null;
}
- 判断键值对数组是否为空或者 null，否则以默认大小 resize()。
- 根据 key 计算的哈希值得到在数组中的所以，如果此时 [i] 为空，直接插入链表头部。
- 不为空判断当前时链表还是红黑树，执行插入，如果 key 相同，则替换。
哈希值的计算其实是经过两遍哈希函数的，先用 key 计算 hashCode，然后用 hashCode 再次进行哈希，保证散列均匀。这个过程有很多位运算，效率比较高。
resize() 扩容方法
当容量达到阈值的时候，就会对数组进行扩容，数组长度发生变化，存储位置 index = h&(length-1) 也会发生变化，需要重新计算 index。
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
//for循环中的代码，逐个遍历链表，重新计算索引位置，将老数组数据复制到新数组中去（数组不存储实际数据，所以仅仅是拷贝引用而已）
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
//将当前entry的next链指向新的索引位置,newTable[i]有可能为空，有可能也是个entry链，如果是entry链，直接在链表头部插入。
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
我们的数组索引位置的计算是通过 对key值的hashcode进行hash扰乱运算后，再通过和 length-1进行位运算得到最终数组索引位置。每次扩容会扩大为原来的两倍。HashMap 的数组长度一定是 2 的次幂是因为这个值可以是 Hash 算法散列的更加均匀。
另外我们重写 equals 方法之后也要重写 hashCode 方法，因为如果 equals 判断两个对象相等了，但是因为没有重写 hashCode 方法在进行 HashMap的相关操作时很有可能拿到错误的值。
另外 HashMap 允许插入 null key 和 value，null key 会被放入到 Table[0]。
String 和 Integer 这样的包装类适合作为 key 是因为：
- 他们时 final 类型，保证了 key 的不可变性，不会出现 hash 值不同的情况。
- 内部重写了 equals 和 hashCode 方法，严格的遵守规范，不会出现 hash 值计算错误。
高并发时 HashMap 会出现的问题
HashMap 的容量时有限的，当经过多次插入时，使得 HashMap 的大小达到了阈值，冲突记录就会很高，这时就需要进行扩容给，resize。
影响发生Resize的因素有两个：
1.Capacity
HashMap的当前长度。上一期曾经说过，HashMap的长度是2的幂。
2.LoadFactor
HashMap负载因子，默认值为0.75f。
衡量HashMap是否进行Resize的条件如下：
HashMap.Size >= Capacity * LoadFactor
扩容的具体步骤：
1.扩容
创建一个新的Entry空数组，长度是原数组的2倍。
2.ReHash
遍历原Entry数组，把所有的Entry重新Hash到新数组。为什么要重新Hash呢？因为长度扩大以后，Hash的规则也随之改变。
让我们回顾一下Hash公式：
index = HashCode（Key） & （Length - 1）
多线程环境下 ReHash 会带来什么问题？
Hashmap的Resize包含扩容和ReHash两个步骤，ReHash在并发的情况下可能会形成链表环，从而造成程序死循环。
在 JDK 1.8 里面修复了这个问题，转移数据时按照链表的正序遍历，在新链表的尾部插入，不会出现逆序，倒置的情况，故不容易成环。
JDK 1.8 HashMap 的改动
hash 算法的优化
增加了红黑树
修复了 rehash 在多线程环境下死循环的问题。