HashMap的整體構成，數組+鏈表+紅黑樹（一種自平衡樹），jdk1.8後加入紅黑樹進行優化。
源碼分析：
1.初始化：new HashMap<>();
//默認加載因子值：當數組空間達到75%，要對數組進行擴容
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//加載因子變量
final float loadFactor;
//設置初始大小
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//默認初始大小
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//數組最大長度2的30次方
static final int MAXIMUM_CAPACITY = 1 << 30;
//數組沒有創建時，表示初始數組容量
//數組創建後，表示數組增長的閾值
int threshold;
//指定初始大小和加載因子
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;
//對指定的長度進行處理，取最接近指定長度且大於指定長度的2的n次方冪
this.threshold = tableSizeFor(initialCapacity);
}
//例如：initialCapacity=9 => threshold=16; initialCapacity=17 => threshold=32;
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;
}
tableSizeFor（int cap）：說明
n |= n >>> 1 將n算數右移，並與n做按位或運算。
9 => 1001 ,右移一位 0100，1001與0100相與，結果是1101；繼續右移兩位 0011，1101與0011相與結果是1111。。繼續右移
可以得到一個結論：經過n |= n >>> 1後，最高位和次到位一定是11； 經過n |= n >>> 2後，高4位一定是1111，後續依次；也就是說，經過多次處理後，n的最高位到最低位都是1。（形如：9（1001）處理後 15（1111）；17（10001）處理後31（11111）），最後返回n+1，剛好是2的m次冪。
注：int n = cap - 1，這裏減一的目的（個人理解）：假設cap == 16（10000），n=cap=16，經處理n = 31（11111），最終返回32，而16剛好是2^4，不需擴展到32。n = cap -1 的目的就是爲了處理這些臨界值。
初始化完成後，僅僅設置了一些必要的參數，HashMap的具體數據結構並沒有創建。
2. 添加數據：V put(K key, V value)，HashMap的核心
//暴露給用戶使用的API
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
//獲取Key對應的Hash值
static final int hash(Object key) {
int h;
//(h = key.hashCode()) ^ (h >>> 16)： 主要是爲了減少Hash衝突，具體原理要結合hashCode源碼
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
//如果鏈表長度大於等於紅黑樹的閾值，則將鏈表轉爲數組
static final int TREEIFY_THRESHOLD = 8;
//具體工作的方法
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//table數組沒有被初始化或者是空數組，需要重新創建或者擴容。
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);
//需要放置的數據與原始數據發生了hash衝突
else {
Node<K,V> e; K k;
//判斷衝突節點的key值是否相同，如果相同則覆蓋原始值
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;
}
//如果發現鏈表中有key與新加key相同，則覆蓋數據。
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;
//size大於閾值則擴容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
擴容代碼：Node<K,V>[] resize()
//hashMap容量擴展
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) {
//閾值設置爲int類型的最大值
threshold = Integer.MAX_VALUE;
return oldTab;
}
//新容量爲舊容量的兩倍，如果舊容量小於默認的初始值，新的閾值在後面計算
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//新的閾值是舊閾值的兩倍
newThr = oldThr << 1; // double threshold
}
//執行邏輯到這裏，表示oldCap==0，即初始分配空間，oldThr>0 表示用戶設置了初始值
//如果用戶使用new HashMap<>(),則oldThr爲0
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//執行邏輯到這裏，也表示初始分配空間，且初始容量爲0
else { // zero initial threshold signifies using defaults
//默認是初始大小16
newCap = DEFAULT_INITIAL_CAPACITY;
//初始閾值0.75*16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//如果newThr==0，兩種情況：
//(1).oldCap > 0 && oldCap < DEFAULT_INITIAL_CAPACITY
//(2).oldCap==0 && oldThr > 0 表示初始分配空間，用戶賦予了初始值
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) {
//將舊數組內的數據置爲空，以便更快的被GC回收
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
//新的數組的容量是舊數組的兩倍，舊數組中節點，在新數組中的位置只有兩種，
//1.原始位置，也就是下標與原來相同；2.原始位置下標+oldCap
//所以會形成兩條鏈，原始位置（loHead）, 原始位置下標+oldCap（hiHead）
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
//判斷是在原始位置，還是在原始位置+oldCap，最終形成兩條鏈表
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);
//loHead鏈表放在原始位置
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//hiHead鏈表放在原始位置+oldCap
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
e.hash & oldCap 說明：判斷數據是在原始位置，還是在原始位置+oldCap；
數據的具體位置由e.hash & (newCap - 1) 確定，oldCap - 1 與 newCap - 1 相比，相差一個最高位，如 oldCap 是（1111），則newCap是（11111）；e.hash & (newCap - 1) 於e.hash & (oldCap - 1) 相比，就是要判斷e.hash 在newCap-1上的最高位上是0 還是 1，如果是0，位置不變，如果是1，位置+oldCap ,而e.hash & oldCap 就是用來判斷e.hash在newCap-1 上的最高位是0還是1.
接下來是重頭戲：紅黑樹
treeifyBin(Node<K,V>[] tab, int hash) ：將鏈表轉爲紅黑樹
//數組長度達到這個閾值，纔會構造紅黑樹
static final int MIN_TREEIFY_CAPACITY = 64;
//構造紅黑樹或者擴容
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
//如果數組長度小於指定值，不構造紅黑樹，而是進行擴容
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
//將鏈表節點替換成樹節點(TreeNode)，將樹節點串成一個新的鏈表
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
do {
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
//將鏈表轉成樹
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
//將鏈表改造成紅黑樹
final void treeify(Node<K,V>[] tab) {
TreeNode<K,V> root = null;
//root：根節點； x：當前要插入的節點；next: 下一個節點
for (TreeNode<K,V> x = this, next; x != null; x = next) {
next = (TreeNode<K,V>)x.next;
x.left = x.right = null;
//設置根節點，根節點爲黑色
if (root == null) {
x.parent = null;
x.red = false;
root = x;
}
//非根節點處理
else {
//k：當前節點則key；h:當前節點的hash值；kc:當前節點key對應的類型；
K k = x.key;
int h = x.hash;
Class<?> kc = null;
//從根節點開始，遍歷查找當前節點所屬的位置
for (TreeNode<K,V> p = root;;) {
//dir:-1 左子樹，1 右子樹；ph: 查找p指針所指向節點的hash值
//pk: 查找指針所指向節點的key值
int dir, ph;
K pk = p.key;
//按照hash值判斷左右
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
//如果hash值相等,需要重新計算dir的值
//comparableClassFor(k)：判斷k是否實現Comparable,是則返回k的class對象，否則返回空
//compareComparables(kc, k, pk)：k.compareTo(pk)
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
//如果dir==0, 則還是無法判斷左右, 調用下面方法繼續處理，一定會返回-1 或者1
dir = tieBreakOrder(k, pk);
TreeNode<K,V> xp = p;
//程序進入判斷體，則表示已經通過遍歷找到了當前節點x 應該插入的位置
if ((p = (dir <= 0) ? p.left : p.right) == null) {
//設置當前節點x的父節點，以及x是在其父節點的左子樹還是右子樹
x.parent = xp;
if (dir <= 0)
xp.left = x;
else
xp.right = x;
//將節點x插入樹中，balanceInsertion方法會對樹進行旋轉，從而達到紅黑樹的要求
root = balanceInsertion(root, x);
break;
}
}
}
}
//經過多次的插入，旋轉後，根節點可能會發生變化，因此要把根節點放到數組空間中。
moveRootToFront(tab, root);
}
紅黑樹原理：
紅黑樹性質：
- 每個節點不是紅色，就是黑色。
- 每個葉子結點（NULL）是黑色。 [注意：這裏葉子結點，是指爲空(NULL)的葉子結點！]
- 根節點是黑色。
- 每個紅色節點的子節點都是黑色。
- 每個結點到葉子結點NIL所經過的黑色結點的個數一樣的。[確保沒有一條路徑會比其他路徑長出倆倍，所以紅黑樹是相對接近平衡的二叉樹的！]
HashMap紅黑樹旋轉變換規則：
- 所有插入節點默認是紅色
- 變色情況：當前節點的父親是紅色，且他的祖父節點的另一個子節點也是紅色（叔叔節點）。
- 把父節點設爲黑色。
- 把叔叔節點也設爲黑色。
- 把祖父節點設置紅色。
- 把當前指針指向祖父節點。
- 旋轉：父親節點是紅色，叔叔節點是黑色。分兩種情況
- 父親節點是左子節點，如果當前節點是右子節點，先以父節點爲基準左旋，然後以重新計算的祖父節點右旋；如果當前節點是左子節點，直接以祖父節點右旋。（以祖父節點旋轉之前，要將父節點變爲黑色，祖父節點變爲紅色）
- 父親節點是右子節點，如果當前節點是左子節點，先以父節點爲基準右旋，然後以重新計算的祖父節點左旋；如果當前節點是右子節點，直接以祖父節點左旋。（以祖父節點旋轉之前，要將父節點變爲黑色，祖父節點變爲紅色）
注：中間有一些臨界情況，如當前節點沒有祖父節點等，可以參看具體代碼。
左旋： 右旋：
TreeNode<K,V> balanceInsertion(TreeNode<K,V> root, TreeNode<K,V> x) ：按照紅黑樹的規則插入數據
· //root:根節點；x:插入節點
static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
TreeNode<K,V> x) {
//紅黑樹規則，插入數據初始爲紅色
x.red = true;
//xp:插入節點的父節點；xpp:插入節點的祖父節點
//xppl:插入節點的祖父節點的左子節點；xppr:插入節點的祖父節點的右子節點
for (TreeNode<K,V> xp, xpp, xppl, xppr;;) {
//插入節點是根節點，根節點是黑色
if ((xp = x.parent) == null) {
x.red = false;
return x;
}
//父節點是黑色，或者祖父節點爲空，則不需要變色或者旋轉
else if (!xp.red || (xpp = xp.parent) == null)
return root;
//程序進入這裏表示：父節點是祖父節點的左子節點，父節點是紅色
if (xp == (xppl = xpp.left)) {
//父節點的兄弟節點（叔叔節點）是右子節點，如果是紅色，則進行變色處理
if ((xppr = xpp.right) != null && xppr.red) {
xppr.red = false;
xp.red = false;
xpp.red = true;
x = xpp;
}
//否則叔叔節點是黑色，需要進行旋轉
else {
//插入節點是右子樹，進行左旋
if (x == xp.right) {
//以父節點爲基準左旋，引用x指向父節點
root = rotateLeft(root, x = xp);
//重新計算父節點，祖父節點（以引用x指向爲標準）
xpp = (xp = x.parent) == null ? null : xp.parent;
}
//兩種情況：
//1.進行左旋後，接着進行右旋
//2.有沒左旋，插入節點是左子節點，直接進行右旋
if (xp != null) {
//父節點變爲黑色
xp.red = false;
if (xpp != null) {
//祖父節點變爲紅色
xpp.red = true;
//以祖父節點爲基準右旋
root = rotateRight(root, xpp);
}
}
}
}
//程序進入這裏表示：父節點是祖父節點的右子節點，父節點是紅色
else {
//父節點的兄弟節點（叔叔節點）是左子節點，如果是紅色，則進行變色處理
if (xppl != null && xppl.red) {
xppl.red = false;
xp.red = false;
xpp.red = true;
x = xpp;
}
else {
//否則叔叔節點是黑色，需要進行旋轉
if (x == xp.left) {
//以父節點爲基準右旋
root = rotateRight(root, x = xp);
xpp = (xp = x.parent) == null ? null : xp.parent;
}
//同上兩種情況：
//1.進行右旋後，接着進行左旋
//2.有沒右旋，插入節點是右子節點，直接以祖父節點爲基準進行左旋
if (xp != null) {
xp.red = false;
if (xpp != null) {
xpp.red = true;
//以祖父節點爲基準左旋
root = rotateLeft(root, xpp);
}
}
}
}
}
}
接着分析左旋和右旋：
//左旋；p：基準節點
//兩種情況：1.p是父節點；2.p是祖父節點
static <K,V> TreeNode<K,V> rotateLeft(TreeNode<K,V> root,
TreeNode<K,V> p) {
//r: 基準節點的右子節點；pp: 基準節點的父節點；rl: r的左子節點；
TreeNode<K,V> r, pp, rl;
//p是祖父節點：父節點一定是祖父節點的右子節點
//p是父節點：插入節點一定是右子節點
//原因在balanceInsertion()方法中可以看到
//下面以p是父節點爲例說明，則r是插入節點
if (p != null && (r = p.right) != null) {
//插入節點的左子樹賦值給基準節點的右子樹
if ((rl = p.right = r.left) != null)
//改變插入節點左子節點的父節點指向
rl.parent = p;
//改變插入節點的父節點指向，如果指向爲空，表示插入節點爲root節點
if ((pp = r.parent = p.parent) == null)
//根節點爲黑色
(root = r).red = false;
//如果基準節點是左節點，則插入節點也應設置爲左節點，否則插入節點是右節點
else if (pp.left == p)
pp.left = r;
else
pp.right = r;
//插入節點的左節點設置爲p節點
r.left = p;
//p節點父節點指向插入節點
p.parent = r;
}
return root;
}
//右旋；與左旋對稱，邏輯與左旋相同
static <K,V> TreeNode<K,V> rotateRight(TreeNode<K,V> root,
TreeNode<K,V> p) {
TreeNode<K,V> l, pp, lr;
if (p != null && (l = p.left) != null) {
if ((lr = p.left = l.right) != null)
lr.parent = p;
if ((pp = l.parent = p.parent) == null)
(root = l).red = false;
else if (pp.right == p)
pp.right = l;
else
pp.left = l;
l.right = p;
p.parent = l;
}
return root;
}
