写在前面：
Java为了更方便的使用数据结构中的映射机制，提供了Java.util.Map接口，Map接口有4个常用的实现类：HashMap、LinkedHashMap、HashTable、TreeMap。在这篇博客中，我们将分实现原理。。。来对JDK8下的HashMap源码分析。
Java集合框架关系图：
Map的4个实现类对比：
（1）HashMap：HashMap保存了一个键值对，即一个key对应唯一一个value。HashMap在大多数情况下，可以迅速的定位到key所对应的值，但是HashMap的遍历是无序的。HashMap只允许一个key为null，允许多个value为null。HashMap是非线程安全的，并发访问资源时，可以使用ConcurrentHashMap来替代。
（2）HashTable：与HashMap类似，但是是线程安全的，在同一时刻，只能有一个线程访问HashTablen内的资源，但是这样做却牺牲了效率，与HashMap一样，可以使用ConcurrentHashMap来替代。
（3）LinkedHashMap：HashMap的子类，保存了记录的插入顺序，在用Iterator遍历的时候，先得到的记录肯定是先插入的。
（4）TreeMap：实现SortedMap接口，能够将保存的顺序，根据键值升序，或者指定比较器排序。在用Iterator遍历的时候，得到的就是排序过的键值对。
HashMap结构：
我们都知道，数组的查找效率很高，但是插入和删除的效率不是很好。而链表只需要改变节点的指向，就可以很好的解决数组的插入和删除问题。为了结合数组和链表的特性，我们要找到一种寻址容易，且插入删除也容易的数据结构---哈希表。
哈希表有多种实现方式入开放地址法，链地址法，在Java中采用链地址法，也就是说Java中HashMap是数组+链表+红黑树的组合实现。链地址法很好的解决了Hash冲突，那么什么是Hash冲突呢？在put方法实现时，我们需要根据Key值找到对应的数组索引，在这个数组索引的位置插入键值对。但是由于不同的Key值在散列函数的计算之后，可能会得到相同的索引，这就发生了Hash冲突，也成为Hash碰撞。而一个优秀的Hash函数会尽量避免Hash冲突。
接下来，我们通过源码分别来看HashMap的底层存储机制：
- HashMap-put方法源码：
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;
if ((p = tab[i = (n - 1) & hash]) == null)
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))))
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);
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;
}
}
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;
}
- put方法实现过程：
（1）令tab=table数组，判断数组tab是否为null，或者长度是否为0？如果不为空或不为0，则创建一个数组，否则resize().
（2）在一个长度为16的数组中，数组中的元素存储的是链表的头结点，那么第二步就是确定数组索引，索引i=(n-1)&hash,hash则是我们通过hash方法对键key的计算结果。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}hash算法会对传入的key求hashcode()，然后进行无符号右移运算，最后进行按位异或运算。
如果tab[i]=null，则创建一个结点并添加转向（6）。如果不为null，则进入else，转向（3）。
（3）判断tab[i]的首个元素是否和key一样，如果一样，则直接覆盖value。如果不相同，转向（4）。
（4）判断tab[i]是否为红黑树，如果是，则直接在树中插入键值对，否则转向（5）。
（5）遍历tab[I]，判断链表长度是否>8,如果>8,则转为红黑树，在红黑树中执行插入操作，否则就执行链表的插入操作。
（6）插入成功后，判断实际存在的键值对是否>threshod，如果大于则扩容。
注：我们之前说过，HashMap是采用拉链式存储，即数组+链表+红黑树，例如：传入一个键值对A，key=1，对应的value=“abc”，如果计算key的hash值=0，那么tab[0]=键值对A,又传入一个键值对B，key=2，对应的value=“def”，那么假如key=2的hash值也=0，首先判断，键值对B的索引tab[0]上存放的首个元素的Key是否=传入的Key，显然1不等于2，那么我们就要判断是否为红黑树，如果是红黑树，那么在树中插入键值对B，如果不是红黑树，那么tab[0]存放的链表头部插入键值对B。
这样做之后，也会始终保证，tab[i]的头节点，是最新插入的键值对，且不重复。
------------------------------------------------------------------------
- 为什么HashMap的大小是2的次幂？
我们看到putval方法中的第四行，p=tab[i=(n-1)&h]，这句代码，n为HashMap为数组初始化的长度，h是key经过hash方法计算出来的值，h再经过（n-1）的位与运算，来找到数组的索引位置。
那这与2的次幂有什么关系呢？因为当我们的n=2的次幂时，(n-1)&h=h%n，但是因为位运算的效率更高，所以我们只要保证输入为2的次幂，或者经过处理之后为2的次幂，第一让我们分配数组索引更合理，尽量避免了Hash冲突第二点就是位运算使得算法效率更高。
此外，接下来的resize方法中，我们每次也都是将容量扩大为原来的2倍。
------------------------------------------------------------------------
- HashMap提供的字段：
在HashMap提供的字段中，我们可以看到HashMap默认初始化的容量为16，加载因子为0.75，而threshold是下次扩容的临界值=capacity*loadFactor。也就是在默认情况下，当元素到达12的时候，就会扩容，并且容量为16的2倍，即32。
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;//默认初始化容量为1<<4=16
static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量为2的30次方
static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认加载因为=0.75
static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64;
transient Node<K, V>[] table;//存放链表的数组
transient Set<Map.Entry<K, V>> entrySet;
transient int size;//已存元素的个数
transient int modCount;
int threshold;//表示下次扩容的临界值，当size>=threshold时，扩容
final float loadFactor;//加载因子- HashMap构造方法：
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}- HashMap-resize方法源码：
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) {
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
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);
}
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) {
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 { // 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;
}