一、HashMap概述

　　HashMap是常用的Java集合之一，是基于哈希表的Map接口的實現。與HashTable主要區別為不支持同步和允許null作為key和value。由于HashMap不是線程安全的，如果想要線程安全，可以使用ConcurrentHashMap代替。

二、HashMap數據結構

　　HashMap的底層是哈希數組，數組元素為Entry。HashMap通過key的hashCode來計算hash值，當hashCode相同時，通過“拉鏈法”解決沖突

　　相比于之前的版本，jdk1.8在解決哈希沖突時有了較大的變化，當鏈表長度大于閾值（默認為8）時，將鏈表轉化為紅黑樹，以減少搜索時間。原本Map.Entry接口的實現類Entry改名為了Node。轉化為紅黑樹時改用另一種實現TreeNode。?

Node類

static class Node<K,V> implements Map.Entry<K,V> {final int hash; // 哈希值final K key;V value;Node<K,V> next; // 指向下一個節點 Node(int hash, K key, V value, Node<K,V> next) {this.hash = hash;this.key = key;this.value = value;this.next = next;}public final K getKey() { return key; }public final V getValue() { return value; }public final String toString() { return key + "=" + value; }public final int hashCode() {return Objects.hashCode(key) ^ Objects.hashCode(value);}public final V setValue(V newValue) {V oldValue = value;value = newValue;return oldValue;}public final boolean equals(Object o) {if (o == this)return true;if (o instanceof Map.Entry) {Map.Entry<?,?> e = (Map.Entry<?,?>)o;if (Objects.equals(key, e.getKey()) &&Objects.equals(value, e.getValue()))return true;}return false;}}

TreeNode類

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {TreeNode<K,V> parent; // red-black tree linksTreeNode<K,V> left;TreeNode<K,V> right;TreeNode<K,V> prev; // needed to unlink next upon deletionboolean red;TreeNode(int hash, K key, V val, Node<K,V> next) {super(hash, key, val, next);}}

HashMap就是這樣一個Entry（包括Node和TreeNode）數組，Node對象中包含鍵、值和hash值，next指向下一個Entry，用來處理哈希沖突。TreeNode對象包含指向父節點、子節點和前一個節點（移除對象時使用）的指針，以及表示紅黑節點的boolean標識。

三、HashMap源碼分析

1. 主要屬性

transient Node<K,V>[] table; // 哈希數組transient Set<Map.Entry<K,V>> entrySet; // entry緩存Settransient int size; // 元素個數transient int modCount; // 修改次數int threshold; // 閾值，等于加載因子*容量，當實際大小超過閾值則進行擴容final float loadFactor; // 加載因子，默認值為0.75

2. 構造方法

　　以下是HashMap的幾個構造方法。

/*** 根據初始化容量和加載因子構建一個空的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);}/*** 使用初始化容量和默認加載因子(0.75).*/public HashMap(int initialCapacity) {this(initialCapacity, DEFAULT_LOAD_FACTOR);}/*** 使用默認初始化大小(16)和默認加載因子(0.75).*/public HashMap() {this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted }/*** 用已有的Map構造一個新的HashMap.*/public HashMap(Map<? extends K, ? extends V> m) {this.loadFactor = DEFAULT_LOAD_FACTOR;putMapEntries(m, false);}

3. 數據存取

putAll方法

public void putAll(Map<? extends K, ? extends V> m) {putMapEntries(m, true);}/*** Implements Map.putAll and Map constructor** @param m the map* @param evict false when initially constructing this map, else* true (relayed to method afterNodeInsertion).*/final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {int s = m.size();if (s > 0) {if (table == null) { // pre-sizefloat 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); // put核心方法 }}}

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) // table為空或length為0n = (tab = resize()).length; // 初始化if ((p = tab[i = (n - 1) & hash]) == null) // 如果hash所在位置為null，直接puttab[i] = newNode(hash, key, value, null);else { // tab[i]有元素，遍歷節點后添加Node<K,V> e; K k;// 如果hash、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);// 鏈表節點大于閾值8，調用treeifyBin方法，當tab.length大于64將鏈表改為紅黑樹// 如果tab.length < 64或tab為null，則調用resize方法重構鏈表.if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash);break;}// hash、key都相等，此時節點即要更新節點if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))break;p = e;}}// 當前節點e = p.next不為null，表示鏈表中原本存在相同的key，則返回oldValueif (e != null) { // existing mapping for keyV oldValue = e.value;// onlyIfAbsent值為false，參數主要決定存在相同key時是否執行替換if (!onlyIfAbsent || oldValue == null)e.value = value;afterNodeAccess(e);return oldValue;}}++modCount;if (++size > threshold) // 檢查是否超過閾值 resize();afterNodeInsertion(evict);return null; // 原HashMap中不存在相同的key，插入鍵值對后返回null} treeifyBin方法源碼如下： 1 final void treeifyBin(Node<K,V>[] tab, int hash) {2 int n, index; Node<K,V> e;3 //當tab為null或tab.length<64需要進行擴容4 if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)5 resize();6 else if ((e = tab[index = (n - 1) & hash]) != null) {7 TreeNode<K,V> hd = null, tl = null;8 do {9 TreeNode<K,V> p = replacementTreeNode(e, null); 10 if (tl == null) 11 hd = p; 12 else { 13 p.prev = tl; 14 tl.next = p; 15 } 16 tl = p; 17 } while ((e = e.next) != null); 18 if ((tab[index] = hd) != null) 19 //存儲在紅黑樹 20 hd.treeify(tab); 21 } 22 }

?

現在我們來看一下為什么需要擴容：

1 /**2 * The bin count threshold for using a tree rather than list for a3 * bin. Bins are converted to trees when adding an element to a4 * bin with at least this many nodes. The value must be greater5 * than 2 and should be at least 8 to mesh with assumptions in6 * tree removal about conversion back to plain bins upon7 * shrinkage.8 */9 static final int TREEIFY_THRESHOLD = 8; 10 11 /** 12 * The smallest table capacity for which bins may be treeified. 13 * (Otherwise the table is resized if too many nodes in a bin.) 14 * Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts 15 * between resizing and treeification thresholds. 16 */ 17 static final int MIN_TREEIFY_CAPACITY = 64;

?

MIN_TREEIFY_CAPACITY=64 > 4 * TREEIFY_THRESHOLD=4*8=32

如上圖：轉化紅黑樹的table容量最小容量64（JDK8定義的是64），至少是4*TREEIFY_THRESHOLD（單鏈表節點個數閥值，用以判斷是否需要樹形化）=32。用以避免 在擴容和樹形結構化的閥值 可能產生的沖突。所以如果小于64必須要擴容。

?三、get查找

可見外部查找和JDK7差別不大，只是原本是entry[]查詢，JDK8編程Node[]查詢.都是 hash(key)找到table中元素位置,再遍歷找到鏈表（或者是紅黑樹）元素的key。根據元素類型判斷到底是查詢哪個類型

1 public V get(Object key) {2 Node<K,V> e;3 return (e = getNode(hash(key), key)) == null ? null : e.value;4 }5 6 /**7 * Implements Map.get and related methods8 *9 * @param hash hash for key 10 * @param key the key 11 * @return the node, or null if none 12 */ 13 final Node<K,V> getNode(int hash, Object key) { 14 Node<K,V>[] tab; Node<K,V> first, e; int n; K k; 15 if ((tab = table) != null && (n = tab.length) > 0 && 16 (first = tab[(n - 1) & hash]) != null) { 17 if (first.hash == hash && // always check first node 18 ((k = first.key) == key || (key != null && key.equals(k)))) 19 return first; 20 if ((e = first.next) != null) { 21 if (first instanceof TreeNode) 22 return ((TreeNode<K,V>)first).getTreeNode(hash, key); 23 do { 24 if (e.hash == hash && 25 ((k = e.key) == key || (key != null && key.equals(k)))) 26 return e; 27 } while ((e = e.next) != null); 28 } 29 } 30 return null; 31 }

?四、resize擴容

第二部put的時候，有可能需要resize。 因為newCap是oldCap的兩倍所以原節點的索引值要么和原來一樣，要么就是原(索引+oldCap)和JDK 1.7中實現不同這里不存在rehash

1 /**2 * Initializes or doubles table size. If null, allocates in3 * accord with initial capacity target held in field threshold.4 * Otherwise, because we are using power-of-two expansion, the5 * elements from each bin must either stay at same index, or move6 * with a power of two offset in the new table.7 *8 * @return the table9 */ 10 final Node<K,V>[] resize() { 11 Node<K,V>[] oldTab = table; 12 int oldCap = (oldTab == null) ? 0 : oldTab.length; 13 int oldThr = threshold; 14 int newCap, newThr = 0; 15 if (oldCap > 0) { 16 if (oldCap >= MAXIMUM_CAPACITY) { 17 threshold = Integer.MAX_VALUE; 18 return oldTab; 19 } 20 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && 21 oldCap >= DEFAULT_INITIAL_CAPACITY) 22 newThr = oldThr << 1; // double threshold 23 } 24 else if (oldThr > 0) // initial capacity was placed in threshold 25 newCap = oldThr; 26 else { // zero initial threshold signifies using defaults 27 newCap = DEFAULT_INITIAL_CAPACITY; 28 newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); 29 } 30 if (newThr == 0) { 31 float ft = (float)newCap * loadFactor; 32 newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? 33 (int)ft : Integer.MAX_VALUE); 34 } 35 threshold = newThr; 36 @SuppressWarnings({"rawtypes","unchecked"}) 37 Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; 38 table = newTab; 39 if (oldTab != null) { 40 for (int j = 0; j < oldCap; ++j) { 41 Node<K,V> e; 42 if ((e = oldTab[j]) != null) { 43 oldTab[j] = null; 44 if (e.next == null) 45 newTab[e.hash & (newCap - 1)] = e; 46 else if (e instanceof TreeNode) 47 ((TreeNode<K,V>)e).split(this, newTab, j, oldCap); 48 else { // preserve order 49 Node<K,V> loHead = null, loTail = null; 50 Node<K,V> hiHead = null, hiTail = null; 51 Node<K,V> next; 52 do { 53 next = e.next; 54 if ((e.hash & oldCap) == 0) { 55 if (loTail == null) 56 loHead = e; 57 else 58 loTail.next = e; 59 loTail = e; 60 } 61 else { 62 if (hiTail == null) 63 hiHead = e; 64 else 65 hiTail.next = e; 66 hiTail = e; 67 } 68 } while ((e = next) != null); 69 if (loTail != null) { 70 loTail.next = null; 71 newTab[j] = loHead; 72 } 73 if (hiTail != null) { 74 hiTail.next = null; 75 //把節點移動新的位置j+oldCap,這種情況不適用與鏈表的節點數大于8的情況 76 //鏈表節點大于8的情況會轉換為紅黑樹存儲 77 newTab[j + oldCap] = hiHead; 78 } 79 } 80 } 81 } 82 } 83 return newTab; 84 }

五.HashMap節點紅黑樹存儲

好了終于到treeify了，大部分內容都在注解中

1 final void treeify(Node<K,V>[] tab) {2 TreeNode<K,V> root = null;3 for (TreeNode<K,V> x = this, next; x != null; x = next) {4 next = (TreeNode<K,V>)x.next;5 x.left = x.right = null;6 if (root == null) {7 x.parent = null;8 x.red = false;9 root = x; 10 } 11 else { 12 K k = x.key; 13 int h = x.hash; 14 Class<?> kc = null; 15 //遍歷root，把節點x插入到紅黑樹中，執行先插入，然后進行紅黑樹修正 16 for (TreeNode<K,V> p = root;;) { 17 int dir, ph; 18 K pk = p.key; 19 if ((ph = p.hash) > h) 20 dir = -1; 21 else if (ph < h) 22 dir = 1; 23 else if ((kc == null && 24 (kc = comparableClassFor(k)) == null) || 25 (dir = compareComparables(kc, k, pk)) == 0) 26 dir = tieBreakOrder(k, pk);//比較k和pk的值，用于判斷是遍歷左子樹還是右子樹 27 TreeNode<K,V> xp = p; 28 if ((p = (dir <= 0) ? p.left : p.right) == null) { 29 x.parent = xp; 30 if (dir <= 0) 31 xp.left = x; 32 else 33 xp.right = x; 34 //修正紅黑樹 35 root = balanceInsertion(root, x); 36 //退出循環 37 break; 38 } 39 } 40 } 41 } 42 moveRootToFront(tab, root); 43 }

上面主要做的是紅黑樹的insert，我們知道紅黑樹insert后是需要修復的，為了保持紅黑樹的平衡，我們來看下紅黑樹平衡的幾條性質：
1.節點是紅色或黑色。
2.根是黑色。
3.所有葉子都是黑色（葉子是NIL節點）。
4.每個紅色節點必須有兩個黑色的子節點。（從每個葉子到根的所有路徑上不能有兩個連續的紅色節點。）
5.從任一節點到其每個葉子的所有簡單路徑都包含相同數目的黑色節點。

當insert一個節點之后為了達到平衡，我們可能需要對節點進行旋轉和顏色翻轉（上面的balanceInsertion方法）。

1 static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,2 TreeNode<K,V> x) {3 //插入的節點必須是紅色的，除非是根節點 4 x.red = true;5 //遍歷到x節點為黑色,整個過程是一個上濾的過程6 //xp=x.parent;xpp=xp.parent;xppl=xpp.left;xppr=xpp.right;7 for (TreeNode<K,V> xp, xpp, xppl, xppr;;) {8 if ((xp = x.parent) == null) {9 x.red = false; 10 return x; 11 } 12 //如果xp的黑色就直接完成，最簡單的情況 13 else if (!xp.red || (xpp = xp.parent) == null) 14 return root; 15 //如果x的父節點是x父節點的左節點 16 if (xp == (xppl = xpp.left)) { 17 //x的父親節點的兄弟是紅色的（需要顏色翻轉） 18 if ((xppr = xpp.right) != null && xppr.red) { 19 //x父親節點的兄弟節點置成黑色 20 xppr.red = false; 21 //父幾點和其兄弟節點一樣是黑色 22 xp.red = false; 23 //祖父節點置成紅色 24 xpp.red = true; 25 //然后上濾（就是不斷的重復上面的操作） 26 x = xpp; 27 } 28 else { 29 //如果x是xp的右節點整個要進行兩次旋轉,先左旋轉再右旋轉 30 if (x == xp.right) { 31 root = rotateLeft(root, x = xp); 32 xpp = (xp = x.parent) == null ? null : xp.parent; 33 } 34 if (xp != null) { 35 xp.red = false; 36 if (xpp != null) { 37 xpp.red = true; 38 root = rotateRight(root, xpp); 39 } 40 } 41 } 42 } 43 //以左節點鏡像對稱就不做具體分析了 44 else { 45 if (xppl != null && xppl.red) { 46 xppl.red = false; 47 xp.red = false; 48 xpp.red = true; 49 x = xpp; 50 } 51 else { 52 if (x == xp.left) { 53 root = rotateRight(root, x = xp); 54 xpp = (xp = x.parent) == null ? null : xp.parent; 55 } 56 if (xp != null) { 57 xp.red = false; 58 if (xpp != null) { 59 xpp.red = true; 60 root = rotateLeft(root, xpp); 61 } 62 } 63 } 64 } 65 } 66 }

出處：

https://www.cnblogs.com/dennyzhangdd/p/6745282.html

http://blog.csdn.net/u014026363/article/details/56342142

http://www.cnblogs.com/skywang12345/p/3245399.html

總結

以上是生活随笔為你收集整理的【Java深入研究】9、HashMap源码解析（jdk 1.8）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。