1.HashMap結構
HashMap基於數組，通過散列函數在O(1)時間內來訪問記錄。首先HashMap裏面實現一個靜態內部類Entry，Map裏面的內容都保存在Entry[]裏面。然後，通過對key的hashcode & 數組長度得到在數組中位置，如有衝突，則在衝突位置形成鏈表，即拉鍊法。
2.HashMap字段屬性
2.1數組table和初始容量
//初始化使用，長度總是 2的冪
transient Node<K,V>[] table;
//默認 HashMap 集合初始容量爲16（必須是 2 的倍數）
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//集合的最大容量，如果通過帶參構造指定的最大容量超過此數，默認還是使用此數
static final int MAXIMUM_CAPACITY = 1 << 30;
HashMap是由數組+鏈表+紅黑樹組成，這裏的數組就是 table 字段。其進行初始化長度默認是 DEFAULT_INITIAL_CAPACITY= 16。
而且由於哈希算法爲了避免衝突都要求數組長度是質數，所以JDK 聲明數組的長度總是 2的n次方(合數)。
2.2裝載因子loadFactor
裝載因子，是用來衡量 HashMap 滿的程度，計算HashMap的實時裝載因子的方法爲：size/capacity，而不是佔用桶的數量去除以capacity。capacity 是桶的數量，也就是 table 的長度length。
默認的負載因子0.75 是對空間和時間效率的一個平衡選擇，建議大家不要修改，除非在時間和空間比較特殊的情況下，如果內存空間很多而又對時間效率要求很高，可以降低負載因子loadFactor 的值；相反，如果內存空間緊張而對時間效率要求不高，可以增加負載因子 loadFactor 的值，這個值可以大於1。
//默認的裝載因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//調整大小的下一個大小值（容量*加載因子）。capacity * load factor
int threshold;
//散列表的加載因子。
final float loadFactor;
//此映射中包含的鍵值映射的數量。（集合存儲鍵值對的數量）
transient int size;
2.3其他
//(JDK1.8新增)當桶(bucket)上的結點數大於這個值時會轉成紅黑樹
static final int TREEIFY_THRESHOLD = 8;
//(JDK1.8新增)當桶(bucket)上的節點數小於這個值時會轉成鏈表
static final int UNTREEIFY_THRESHOLD = 6;
//(JDK1.8新增)當集合中的容量大於這個值時，表中的桶才能進行樹形化 ，否則桶內元素太多時會擴容，而不是樹形化 爲了避免進行擴容、樹形化選擇的衝突，這個值不能小於 4 * TREEIFY_THRESHOLD
static final int MIN_TREEIFY_CAPACITY = 64;
3.HashMap的存取實現
3.1hashcode
public int hashCode():HashCode是根類Obeject中的方法。默認情況下，Object中的hashCode() 返回對象的32位jvm內存地址。也就是說如果對象不重寫該方法，則返回相應對象的32爲JVM內存地址。
3.2hash
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
i = (table.length - 1) & hash;//這一步是在後面添加元素putVal()方法中進行位置的確定
一共分三步：
（1）取 hashCode 值： key.hashCode()
（2）高位參與運算：h>>>16
hashCode() 在很多時候下低位是相同的，這將導致衝突（碰撞），因此 1.8 以後做了個移位操作：將元素的 hashCode() 和自己右移 16 位後的結果求異或。
這樣就使得 hashCode()是由高位和低位共同決定，在數組長度較小時，降低衝突。
（3）取模運算：(n-1) & hash
爲降低取模運算( hash%length)的開銷，HashMap 通過 hash & (table.length -1)來得到該對象的保存位，HashMap 底層數組的長度總是2的n次方，這是HashMap在速度上的優化。當 length 總是2的n次方時，hash & (length-1)運算等價於對 length 取模，也就是 hash%length，因爲&比%具有更高的效率。比如 n % 32 = n & (32 -1)。
3.3put
//hash(key)就是上面講的hash方法，對其進行了第一步和第二步處理
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;
//（1）如果table爲null或者長度爲0，則進行初始化：resize()方法本來是用於擴容，由於初始化沒有實際分配空間，這裏用該方法進行空間分配
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//（2）這裏用到了前面講解獲得key的hash碼的第三步，取模運算
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//（3）----------------------------------
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//（4）該鏈是紅黑樹--------------------------------
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//（5）該鏈是鏈表
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;
}
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;//用作修改和新增快速失敗
//（6）超過最大容量，進行擴容
if (++size > threshold)
resize();
afterNodeInsertion(evict);// 這都是一個空的方法實現，LinkedHashMap 是繼承的 HashMap，並且重寫了該方法，相當於一個模板模式裏的一個鉤子，當需要的時候再調用。
return null;
}
（1）初始化：如果哈希表數組table爲空，進行擴容（resize）；
（2）數組尋址：根據鍵值key計算hash值得到插入的數組索引i，
如果table[i]==null，直接新建節點添加，轉向（6）；
如果table[i]不爲空，轉向（3）；
（3）添加value（首元素判定）：判斷table[i]的首個元素是否和key相同，（需重寫hashCode以及equals）
如果相同直接覆蓋value；
否則轉向（4）；
（4）添加value（紅黑樹判定）：判斷table[i] 是否爲treeNode（紅黑樹），
如果是紅黑樹，則直接在樹中插入鍵值對；
否則轉向（5）；
（5） 添加value（鏈表判定）：遍歷table[i]，判斷鏈表長度是否大於8，
如果是，則把鏈表轉換爲紅黑樹，在紅黑樹中執行插入操作；
否則進行鏈表的插入操作；
（6）擴容：插入成功後，判斷實際存在的鍵值對數量size是否超過了最大容量threshold，如果超過，進行擴容。
3.3.1 resize
由於 HashMap 擴容開銷很大，因此與擴容相關的兩個因素：
- 容量capacity：數組長度
- 加載因子loadFactor：決定了 HashMap 中的元素佔有多少比例時擴容，size/capacity
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;//原數組如果爲null，則長度賦值0
int oldThr = threshold;
int newCap, newThr = 0;
//（1）
if (oldCap > 0) {//如果原數組長度大於0
if (oldCap >= MAXIMUM_CAPACITY) {//數組大小如果已經大於等於最大值(2^30)
threshold = Integer.MAX_VALUE;//修改閾值爲int的最大值(2^31-1)，這樣以後就不會擴容了
return oldTab;
}
//原數組長度大於等於初始化長度16，並且原數組長度擴大1倍也小於2^30次方
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // 閥值擴大1倍
}
else if (oldThr > 0) //舊閥值大於0，則將新容量直接等於就閥值
newCap = oldThr;
else {//閥值等於0，oldCap也等於0（集合未進行初始化）
newCap = DEFAULT_INITIAL_CAPACITY;//數組長度初始化爲16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//閥值等於16*0.75=12
}
//計算新的閥值上限
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;
//（2）
if (oldTab != null) {
//把每個bucket都移動到新的buckets中
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;//元數據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;
}
//原索引+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;
}
擴容分爲兩部分：
（1）首先是計算新桶數組的容量 newCap 和新閾值 newThr；
（2）然後將原集合的元素重新映射到新集合中；
（3）若table[i]的首個元素爲空，直接插入；
（4）若table[i] 爲紅黑樹，split()方法重新分配；如果是紅黑樹，則直接在樹中插入鍵值對；否則轉向（5）；
（5）若table[i] 爲鏈表，只需要看看原來的hash值新增的那個bit是1還是0就好了，是0的話索引沒變，是1的話索引變成“原索引+oldCap”。原因如下：
經過觀測可以發現，我們使用的是2次冪的擴展(指長度擴爲原來2倍)，所以，元素的位置要麼是在原位置，要麼是在原位置再移動2次冪的位置。看下圖可以明白這句話的意思，n爲table的長度，圖（a）表示擴容前的key1和key2兩種key確定索引位置的示例，圖（b）表示擴容後key1和key2兩種key確定索引位置的示例，其中hash1是key1對應的哈希與高位運算結果。
元素在重新計算hash之後，因爲n變爲2倍，那麼n-1的mask範圍在高位多1bit(紅色)，因此新的index就會發生這樣的變化：
因此，我們在擴充HashMap的時候，不需要像JDK1.7的實現那樣重新計算hash，只需要看看原來的hash值新增的那個bit是1還是0就好了，是0的話索引沒變，是1的話索引變成“原索引+oldCap”，可以看看下圖爲16擴充爲32的resize示意圖：
這個設計確實非常的巧妙，既省去了重新計算hash值的時間，而且同時，由於新增的1bit是0還是1可以認爲是隨機的，因此resize的過程，均勻的把之前的衝突的節點分散到新的bucket了。這一塊就是JDK1.8新增的優化點。有一點注意區別，JDK1.7中rehash的時候，舊鏈表遷移新鏈表的時候，如果在新表的數組索引位置相同，則鏈表元素會倒置，但是從上圖可以看出，JDK1.8不會倒置。
4.線程安全
4.1HashMap不是線程安全的
請參考[3]
4.2Hashtable
與HashMap區別：
- Hashtable不允許鍵和值是null，而HashMap不允許；
- Hashtable是同步的，而HashMap不允許。Hashtable通過在put方法上使用synchronized關鍵字實現同步。效率低的原因是所有訪問Hashtable的線程必須競爭同一把鎖。
4.3ConcurrentHashMap
4.3.1ConcurrentHashMap結構
ConcurrentHashMap由Segment數組結構和HashEntry數組結構組成。Segment是一種可重入鎖。一個ConcurrentHashMap裏包含一個Segment數組，一個Segment包含一個HashEntry數組，當對HashEntry裏的數據修改時，必須先獲得對應的Segment鎖。
4.3.2ConcurrentHashMap初始化
分爲三步：
（1）初始化segments數組：爲了能通過按位與的散列算法來定位segments數組的索引，必須保證segments數組長度是2的N次方。
（2）初始化段偏移量（segmentShift）和段掩碼（segmentMask）
（3）初始化每個segment：與初始化HashMap數組相同
4.3.2定位Segment
爲了使用分段鎖Segment，需進行一次再散列。同3.2節。
4.3.3ConcurrentHashMap操作
1.get
get整個過程不需要加鎖，除非讀到null纔會加鎖重讀。這是因爲ConcurrentHashMap的共享變量都是volatile類型，所以可以保證多線程環境下的可見性，能保證多線程的讀（但是隻能單線程寫，但是get不需要寫）。
另外，爲防止衝突，定位Segment和定位HashEntry的散列算法不一致。
2.put
分爲三步：
（1）定位到Segment
（2）判斷是否對Segment裏的HashEntry擴容，
如果需要擴容，則重新定位，插入；
如果不需要擴容，則直接插入。
爲了高效，ConcurrentHashMap不會對整個容器擴容，只對某個Segment擴容。
3.size
最安全但也是最低效的做法：把put、remove和clean全部鎖住再進行size。
ConcurrentHashMap的做法是先嚐試兩次不鎖住Segment的方式來統計size，如果在統計的過程中，size發生變化，再採用加鎖的方式。
參考：[1]https://www.cnblogs.com/ysocean/p/8711071.html#_label5
[2]https://blog.csdn.net/u011240877/article/details/53351188