HashMap的底层实现原理？
关于HashMap的实现，JDK1.8比JDK1.7做了一个比较大的改变。
JDK1.7：
1.7中HashMap底层是通过数组+链表的方式实现的。它的数据节点是entry节点。是它的一个内部类。数据插入过程是使用了头插法。
使用头插法会造成什么问题呢？ 在resize（）扩容的过程，调用了transfer（）方法，把里面的Entry进行了一个rehash，这个过程中可能会造成一个链表的循环，可能在下一次get的过程中出现死循环的现象。也可能是因为他没有加锁，不能保证多线程并发条件下的线程安全。
JDK1.8：
1.8中HashMap底层是通过数组+链表+红黑树的方式实现的。它的数据节点改成了Node节点。数据插入过程是使用了尾插法。当链表长度达到阈值（默认是8，则转为红黑树）。红黑树退化为链表的阈值是6。
HashMap的扩容机制：
初始化HashMap的时候，没有设置capacity的话，默认初始化容量是16，负载因子是0.75。
会计算出来一个threshold，就是扩容的阈值，如果在进行put的时候回先判断当前size是不是大于这个阈值，大于的话就新建一个两倍大小的，将原来的Entry进行resize的过程。
（1）底层实现
JDK1.7：数组+链表
JDK1.8：数组+链表+红黑树
（2）重要变量分析
JDK1.7：
static final int DEFAULT_INITIAL_CAPACITY = 16;//数组初始容量
static final int MAXIMUM_CAPACITY = 1 << 30;//容量最大值
static final float DEFAULT_LOAD_FACTOR = 0.75f;//加载因子
transient Entry[] table;//数据节点：Entry
int threshold;//阈值
JDK1.8：
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 出租初始容量aka 16
static final int MAXIMUM_CAPACITY = 1 << 30;//容量最大值
static final float DEFAULT_LOAD_FACTOR = 0.75f;//加载因子
static final int TREEIFY_THRESHOLD = 8;//链表转为红黑树的阈值
static final int UNTREEIFY_THRESHOLD = 6;//红黑树退化为链表的阈值
transient Node<K,V>[] table;//数据节点：Node
//最小的树化容量，进行树化的时候，还有一次判断，只有键值对数量大于64时才会发生转换，
//这是为了避免在哈希表建立初期，多个键值对恰好被放入了同一个链表而导致不必要的转化
static final int MIN_TREEIFY_CAPACITY = 64;
（3）取值：get(key)
JDK1.7：
（1）首先判断null。如果key值为null，则查找键值为null的value。
（2）key值不为null的话，获取key的hash值，找到hash值在数组中的下标位置。
（3）循环hash值所在桶对应的链表中的Entry节点，如果节点hash值相等且key相等，则返回value。
public V get(Object key) {
if (key == null)
return getForNullKey();//若key为null，则查找键值为null的value
int hash = hash(key.hashCode());//获取key的hash值
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {//获取key的hash值在数组中的下标，得到key所在的桶，循环桶中的Entry节点
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k)))//如果节点hash值相等且key相等，则返回value
return e.value;
}
return null;
}
JDK1.8：
（1）计算key的hash值，如果数组不为空，且长度大于0，待查找的桶不为空，就从第一个Node节点查起，相等直接返回。
（2）如果是树结构，遍历树查找，找到后返回。
（3）如果是链表，则遍历链表后返回。
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) {//如果表不为空&&表长大于0&&待查找的桶不为空
if (first.hash == hash && // 从第一个节点开始，相等直接返回
((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 {//如果是链表则遍历链表，找到后返回
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
（4）存值：put（key，value）
JDK1.7：
（1）首先考虑null。如果原来有null的key，不可以加入，如果原来没有可以加到map中。
（2）计算hash值，找到桶。
（3）如果已经存在key值的Entry，需要覆盖原来的value。如果原来没有key值，则将Entry节点存在map中，并判断是否需要扩容。
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);//判断key为null的情况，如果原来有null的key，不可以加入，如果原来没有可以加到map中
int hash = hash(key.hashCode());//计算hash值
int i = indexFor(hash, table.length);//找到桶
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}//如果key已经存在，则覆盖原来的值
}
modCount++;//如果key不存在，就将Entry节点加到链表中，存在map中
addEntry(hash, key, value, i);
return null;
}
private V putForNullKey(V value) {
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(0, null, value, 0);//节点加到map中，判断是否扩容
return null;
}
//增加 节点
void addEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
if (size++ >= threshold)
resize(2 * table.length);//扩容
}
JDK1.8：
（1）先考虑数组null或者长度为0，则初始化数组。
（2）计算hash值，得到桶的位置。
（3）如果桶为空，直接将节点插入到桶中。
如果桶不为空，首先判断桶中的第一个节点的hash与传入的key的hash是否相等，如果相等，直接覆盖原value。如果不相等，判断是不是树节点，（1）如果是树节点，遍历树添加到红黑树中；（2）如果是链表，则遍历链表，存在相同的key值，则覆盖原来的value。如果不存在相同的key值，则插到链表尾部。并确定链表长度是否达到树化阈值，达到阈值的话链表转成红黑树。
（4）元素增加，判断是否达到阈值，达到后扩容。
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;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;//如果表为空或者表的容量为0，resize初始化表
if ((p = tab[i = (n - 1) & hash]) == null)//根据hash得到在表中索引位置的桶，如果桶为空，则将节点直接插入桶中
tab[i] = newNode(hash, key, value, null);
else { //桶不为空
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))//首先判断桶中第一个节点的hash与待插入元素的key的hash值是否相同且key是否"相等"，如果相等，赋给变量e
e = p;
else if (p instanceof TreeNode) //是树节点，则调用putTreeVal添加到红黑树中
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else { //否则是链表，遍历链表，如果不存在相同的key，则插入链表尾部，并且判断节点数量是否大于树化阈值，如果大于则转换为红黑树；如果存在相同的key，break，遍历链表结束
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
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//e不为空表示存在相同的key，替换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;
}
（5）扩容机制：resize（）
JDK1.7：
（1）首先考虑原始容量已经达到最大容量限制，则直接扩容到Integer的最大值。
（2）建立一个容量为2倍原容量的新Entry表。
（3）transfer（）方法，将原表的Entry都拷贝到新表中，替换旧表。
（这个transfer（）过程中会产生的问题：
首先trasfer的过程为：循环遍历旧表的每个节点，将entry进行了rehash，采用头插法将节点存放到新表。这个过程中，可能会造成链表的循环，在下一次get的过程中发生死循环。这也可能是因为它没有加锁，导致的不能保证多线程并发情况下的线程安全。）（所以JDK1.8对此作了一定的改进，采用了红黑树的数据结构，避免了一个链表的循环。但并不是说HashMap1.8就是线程安全的。）
（4）因为已经扩容，所以更新阈值。
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
//原容量如果达到最大容量，直接扩容到integer的最大值
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];//建立新的Entry表，容量为原来的两倍
transfer(newTable); //将原表中的entry都拷贝到新表中，替换旧表
table = newTable;
threshold = (int)(newCapacity * loadFactor);//更新阈值
}
//将原表中的entry都拷贝到新表中
void transfer(Entry[] newTable) {
Entry[] src = table;
int newCapacity = newTable.length;//新表的容量
for (int j = 0; j < src.length; j++) {//循环旧表中的每个节点
Entry<K,V> e = src[j];
if (e != null) {
src[j] = null;
do {
Entry<K,V> next = e.next;
int i = indexFor(e.hash, newCapacity);//得到每一个Entry节点在新表中的桶位置
//采用头插法，将entry插入新表，得到的新表与原来正好是头尾相反的
e.next = newTable[i];
newTable[i] = e;
e = next;//下一次循环
} while (e != null);
}
}
}
JDK1.8：
额。不行了。。。
请参考其他，等我学清楚后补充。
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;//原表
int oldCap = (oldTab == null) ? 0 : oldTab.length;//原容量
int oldThr = threshold;//原阈值
int newCap, newThr = 0;
if (oldCap > 0) {
//如果旧表容量大于容量最大值，那么阈值为Interger的最大值，即提升阈值，不再进行扩容，返回旧表
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//否则，扩容为原先容量的2倍，阈值也扩容为原来的2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold，即阈值*2
}
//oldCap不大于0，表示该表未被初始化，需要进行初始化，需要确认表的大小及阈值
//旧表容量为0，阈值大于0，则用阈值大小作为容量
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//否则，表的容量为默认初始容量16，阈值为默认初始容量16*加载因子0.75
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//如果新表阈值为0，则利用新容量*加载因子计算
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr; //将新的阈值赋给HashMap的阈值成员变量
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;//根据新的容量建立新表，并赋给旧表
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {//遍历旧表中的每一个桶
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//将不为空的桶rehash到新表中，桶中只有一个元素，直接放到桶中
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 { // preserve order//如果是链表
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
//最高位为0，则将节点加入loTail.next
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
//最高位为1，则将节点加入hiTail.next
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//在新数组的位置与原数组的位置相同,新数组的桶直接指向LoHead
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//在新数组的位置是原数组的位置+旧数组长度,新数组的桶直接指向hiHead
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
