針對各個實作類的特點做一些說明：
(1) HashMap：它根據鍵的hashCode值存儲資料，大多數情況下可以直接定位到它的值，因而具有很快的通路速度，但周遊順序卻是不确定的。 HashMap最多隻允許一條記錄的鍵為null，允許多條記錄的值為null。HashMap非線程安全，即任一時刻可以有多個線程同時寫HashMap，可能會導緻資料的不一緻。如果需要滿足線程安全，可以用 Collections的synchronizedMap方法使HashMap具有線程安全的能力，或者使用ConcurrentHashMap。
(2) Hashtable：Hashtable是遺留類，很多映射的常用功能與HashMap類似，不同的是它承自Dictionary類，并且是線程安全的，任一時間隻有一個線程能寫Hashtable，并發性不如ConcurrentHashMap，因為ConcurrentHashMap引入了分段鎖。Hashtable不建議在新代碼中使用，不需要線程安全的場合可以用HashMap替換，需要線程安全的場合可以用ConcurrentHashMap替換。
(3) LinkedHashMap：LinkedHashMap是HashMap的一個子類，儲存了記錄的插入順序，在用Iterator周遊LinkedHashMap時，先得到的記錄肯定是先插入的，也可以在構造時帶參數，按照通路次序排序。
(4) TreeMap：TreeMap實作SortedMap接口，能夠把它儲存的記錄根據鍵排序，預設是按鍵值的升序排序，也可以指定排序的比較器，當用Iterator周遊TreeMap時，得到的記錄是排過序的。如果使用排序的映射，建議使用TreeMap。在使用TreeMap時，key必須實作Comparable接口或者在構造TreeMap傳入自定義的Comparator，否則會在運作時抛出java.lang.ClassCastException類型的異常。
對于上述四種Map類型的類，要求映射中的key是不可變對象。不可變對象是該對象在建立後它的哈希值不會被改變。如果對象的哈希值發生變化，Map對象很可能就定位不到映射的位置了。
通過上面的比較，我們知道了HashMap是Java的Map家族中一個普通成員，鑒于它可以滿足大多數場景的使用條件，是以是使用頻度最高的一個。下文我們主要結合源碼，從存儲結構、常用方法分析、擴容以及安全性等方面深入講解HashMap的工作原理。
一 構造函數
1.1 HashMap(int initialCapacity)
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
} 這個構造方法調用了1.2中的構造方法。
1.2 HashMap(int initialCapacity, float loadFactor)
//構造一個初始容量為initialCapacity，負載因子為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);
} 設定threshold，這個threshold = capacity * load factor。當HashMap的size到了 threshold時，就要進行resize,也就是擴容。
tableSizeFor()的主要功能是傳回一個比給定整數大且最接近的2的幂次方整數,如給定10,傳回2的4次方16.
我們進入tableSizeFor(int cap) 的源碼中看看:
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
} 詳細請看：https://www.jianshu.com/p/ee0de4c99f87
1.3 HashMap(Map<? extends K, ? extends V> m)
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
} 直接看putMapEntries(m, false)源碼：
//将m的所有元素存入HashMap中
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {
if (table == null) { // pre-size
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)
threshold = tableSizeFor(t);
}
else if (s > threshold)
resize();
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
} putVal的源碼： 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;
} 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;
} 注: hash 沖突發生的幾種情況:
1.兩節點key值相同(hash值一 定相同)，導緻沖突;
2.兩節點key值不同，由于hash函數的局限性導緻hash值相同，沖突;
3.兩節點key值不同，hash 值不同，但hash值對數組長度取模後相同，沖突;
二，為啥是線程不安全的？
1. put的時候導緻多線程資料不一緻
比如有兩個線程A和B，首先A希望插入一個key-value對到HashMap中,首先計算記錄所要落到
的hash桶的索引坐标，然後擷取到該桶裡面的連結清單頭結點，此時線程A的時間片用完了，而此
時線程B被排程得以執行，和線程A-樣執行，不過線程B成功将記錄插到了桶裡面，假設線
程A插入的記錄計算出來的hash桶索弓|和線程B要插入的記錄計算出來的hash桶索引是-樣
的，那麼當線程B成功插入之後,線程A再次被排程運作時，它依然持有過期的連結清單頭但是它對
此一無所知，以至于它認為它應該這樣做，如此一來就覆寫了線程B插入的記錄，這樣線程B插
入的記錄就憑空消失了，造成了資料不一緻的行為。
2. resize而引|起死循環
這種情況發生在HashMap自動擴容時，當2個線程同時檢測到元素個數超過數組大小x負載因
子。此時2個線程會在put(方法中調用了resize(),兩個線程同時修改-個連結清單結構會産生-個
循環連結清單(JDK1.7中, 會出現resize前後元素順序倒置的情況)。接下來再想通過get()擷取某
一個元愫，就會出現死循環。
三 HashMap和HashTable的差別
HashMap和Hashtable都實作了Map接口，但決定用哪一個之 前先要弄清楚它們之間的分别。主要
的差別有:線程安全性,同步(synchronization), 以及速度。
1. HashMap幾乎可以等價于Hashtable,除了HashMap是非synchronized的,
可以接受為null的鍵值(key)和值(value)，而Hashtable則不行。
2. HashMap是非synchronized,而Hashtable是synchronized, 這意味着Hashtable是線程安全
的，多個線程可以共享一個Hashtable; 而如果沒有正确的同步的話，多個線程是不能共享
HashMap的。Java 5提供了ConcurrentHashMap,它是HashTable的替代， 比HashTable的擴 展
性更好。
3.另一個差別是HashMap的疊代器(lterator)是fail-fast疊代器，而Hashtable的enumerator疊代器
不是fail-fast的。是以當有其它線程改變了HashMap的結構(增加或者移除元素)，将會抛出
ConcurrentModificationException,但疊代器本身的remove()方法移除元素則不會抛出
ConcurrentModificationException異常。這并不是一個發生的行為，要看JVM。這條同
樣也是Enumeration和Iterator的差別。
4.由于Hashtable是線程安全的也是synchronized,是以在單線程環境下它比HashMap要慢。如
果你不需要同步，隻需要單一線程, 那麼使用HashMap性能要好過Hashtable。
5. HashMap不能保證随着時間的推移Map中的元素次序是不變的。
注意一下重要術語：
1. sychronized意味着在一次僅有一個線程能夠更改Hashtable。就是說任何線程要更新Hashtable
時要首先獲得同步鎖，其他線程要等到同步鎖被釋放之後才能再次獲得同步鎖更新Hashtable。
2. Fail-safe和iterator疊代器相關。如果某個集合對象建立了Iterator或者Listlterator,然後其它的
線程試圖"結構上”更改集合對象，将會抛出ConcurrentModificationException異常。但其它線
程可以通過set()方法更改集合對象是允許的，因為這并沒有從“結構上”更改集合。但是假如已
經從結構上進行了更改,再調用set()方法, 将會抛出llgalArgumentException異常。
3.結構上的更改指的是删除或者插入一個素，這樣會影響到map的結構。