- 下面參考博文，感謝！
- Java 8系列之重新認識HashMap
- 全方面（主要是jdk1.8的源碼分析）
- HashMap源碼分析（jdk1.8，保證你能看懂）
- 全方面（主要講解put過程、擴容過程等）
- 用漫畫告訴你—什麼是HashMap？
- 主要講解 HashMap 的數據結構、哈希桶數組索引、hash算法以及各常量設計的巧妙之處等
- 一幅漫畫告訴你，什麼是紅黑樹
- 正文
基本概念
- HashMap 是最常用的集合類框架之一，它實現了 Map 接口，所以存儲的元素也是鍵值對映射的結構，並允許使用 null值 和 null鍵，其內元素是無序的，如果要保證有序，可以使用 LinkedHashMap（插入順序）。
- HashMap是線程不安全的，所以纔有了 ConcurrentHashMap。也可以通過
Collections.synchronizedMap()這個方法來使 HashMap 變爲線程安全的。 - HashMap最多隻允許一條記錄的鍵爲null，允許多條記錄的值爲null。
- 它是根據鍵的
hashCode值來存儲數據的，大多數情況下可以直接定位到它的值，因而具有很快的訪問速度，但遍歷順序卻是不確定的。 - 繼承關係如下:
- HashMap是線程不安全的，所以纔有了 ConcurrentHashMap。也可以通過
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {···}
數據結構
- HashMap 的數據結構是 數組 + 鏈表 + 紅黑樹（jdk1.8增加了紅黑樹部分）
- 數組
- 連續的內存，通過下標可以快速進行尋址。
- 插入結點困難
- 當在數組中插入一個元素時，後面的元素都得往後移動，然後才能進行操作，比較麻煩。
- 單鏈表
- 插入、刪除數據方便（直接修改節點指針）
- 查詢效率低（遍歷結點、時間複雜度O(n)）
- 紅黑樹
- 一種自平衡的二叉查找樹，除了符合二叉查找樹的基本特性外，還具有以下特性：
- 二叉查找樹，左子樹元素大於右子樹，最大的查找次數爲樹高。
- 節點是紅色或黑色。
- 根節點是黑色。
- 每個葉子節點都是黑色的空節點（NIL節點）。
- 每個紅色節點的兩個子節點都是黑色。(從每個葉子到根的所有路徑上不能有兩個連續的紅色節點)
- 從任一節點到其每個葉子的所有路徑都包含相同數目的黑色節點。
- 紅黑樹的這些規則，保證了紅黑樹的自平衡。
- 但是，當插入、刪除節點時，這些規則可能會被打破，導致紅黑樹不再是一個紅黑樹了。這時就需要做出一些調整，調整方法有：變色、旋轉（左旋、右旋）。
- 變色就是將紅色變爲黑色，黑色變爲紅色，爲了滿足上面的條件
- 注意：變色會發生連鎖反應，所以要經過多次變色。
- 左旋轉
- 逆時針旋轉紅黑樹的兩個節點，使得父節點被自己的右孩子取代，而自己成爲自己的左孩子。
- 右旋轉
- 順時針旋轉紅黑樹的兩個節點，使得父節點被自己的左孩子取代，而自己成爲自己的右孩子。
- 變色就是將紅色變爲黑色，黑色變爲紅色，爲了滿足上面的條件
- 一種自平衡的二叉查找樹，除了符合二叉查找樹的基本特性外，還具有以下特性：
源碼分析
- 下文的源碼是基於
jdk1.8版本來進行分析的- 之前
jdk1.7的存儲結構是數組+鏈表 ( 拉鍊式 )，到了jdk1.8變成了數組+鏈表+紅黑樹。- 不是說變成了紅黑樹效率就一定提高了，只有在鏈表的長度不小於8，而且數組的長度不小於64的時候纔會將鏈表轉化爲紅黑樹。
jdk1.7版本增刪效率高，jdk1.8版本增刪、查找效率都高。jdk1.8版本的優化在擴容機制的數組元素轉移的地方有很巧妙設計的體現。
- 另外，HashMap 是非線程安全的，也就是說在多個線程同時對 HashMap 中的某個元素進行增刪改操作的時候，是不能保證數據的一致性的。
- 之前
數據結構表示
- 最終的數據結構整體是數組，然後每個數組元素是一個鏈表的節點。當發生衝突時，在節點處使用尾插法插入節點。當鏈表長度大於8之後（在數組長度大於64的前提下），鏈表就會轉換爲紅黑樹了。
- 鏈表節點的表示：
- 存儲了 hash 碼，Key、Value、鏈表的指針域（指向下一個節點）。
//HashMap的靜態內部類 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) {···}
public final K getKey() {···}
public final V getValue() {···}
public final String toString() {···}
public final int hashCode() {···}
public final V setValue(V newValue) {···}
public final boolean equals(Object o) {···}
}
- 紅黑樹的表示：
- 存儲了 雙親結點、左子樹、右子樹、前一個元素的節點、是否爲紅色（布爾值）。
- 另外由於它繼承自 LinkedHashMap.Entry ，而 LinkedHashMap.Entry 繼承自 HashMap.Node ，因此還有額外的 6 個屬性。
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
···
}
//繼承 LinkedHashMap.Entry 的
Entry<K,V> before, after;
//HashMap.Node 的
final int hash;
final K key;
V value;
Node<K,V> next;
幾個常量、變量
- 其中，閾值:
threshold=capacity*loadFactory。 - 注意這三個變量的區別：
threshold、size、length。 modCount記錄的HashMap結構的改變是指 HashMap中的 映射數 或以 其他方式修改其 內部結構。- 注意：某個key對應的value值被覆蓋不屬於結構變化的。
//默認數組容量大小：16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//數組最大容量大小：2 的 30 次方
static final int MAXIMUM_CAPACITY = 1 << 30;
//默認的加載因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//使用樹而不是鏈表的計數閾值，將元素添加到至少這麼多的節點的鏈表中時，鏈表將轉換爲樹
static final int TREEIFY_THRESHOLD = 8;
//可以進行樹化的最小數組容量
static final int MIN_TREEIFY_CAPACITY = 64;
//存儲鍵值對元素的數組，分配後，長度始終是 2 的冪（哈希桶數組）
transient Node<K,V>[] table;
//此映射中包含的鍵-值映射數，即當前數組中的元素數量
transient int size;
//主要用於記錄HashMap內部結構發生變化的次數。
transient int modCount;
//哈希表所能容納的最大鍵值對個數，下次擴容的臨界值，size>=threshold 數組就會擴容
int threshold;
//負載因子
final float loadFactor;
構造方法
HashMap有四個構造方法，如下：
/**
* 使用默認的初始容量（16）和默認的加載因子（0.75）構造一個空的 HashMap
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* 構造一個新的 HashMap ，其映射與指定的 Map 相同。
* HashMap 是使用默認負載因子（0.75）和足以將映射保存在指定的 Map 中的初始容量創建的
*/
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
/**
* 構造一個帶指定初始容量和加載因子的空 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);
}
-
這裏簡單的說一下構造方法中的兩個東西
-
initialCapacity初始容量- 官方要求我們要輸入一個2的N次冪的值，比如說2、4、8、16等等這些，但是我們忽然一個不小心，輸入了一個20怎麼辦？沒關係，虛擬機會根據你輸入的值，找一個離20最近的2的N次冪的值，比如說16離他最近，就取16爲初始容量。
-
loadFactor負載因子- 默認值是0.75。負載因子表示一個散列表的空間的使用程度，有這樣一個公式：
initailCapacity*loadFactor = HashMap的容量。 - 所以負載因子越大則散列表的裝填程度越高，也就是能容納更多的元素，元素多了，鏈表大了，所以此時索引效率就會降低。反之，負載因子越小則鏈表中的數據量就越稀疏，此時會對空間造成爛費，但是此時索引效率高。
- 默認值是0.75。負載因子表示一個散列表的空間的使用程度，有這樣一個公式：
確定哈希桶數組索引位置
- 主要是hash算法（均勻的）。
jdk1.8版本將這個過程的一部分融入到了put()過程中。- 首先我們知道 HashMap 是根據 Key 的 hashCode來確定鍵值對在哈希桶數組的位置的。得到了hash值之後又該怎麼做呢？首先想到的是取模，當然，肯定不是這樣的，不然人人都能當大牛了_。其實是通過巧妙的位運算來操作的（更高效）。
- 下面就是 HashMap 中的
hash()方法的實現。
- 下面就是 HashMap 中的
//經過兩步操作最後得到的纔是我們用來確定位置的hash值
static final int hash(Object key) {
int h;
// h = key.hashCode() 爲第一步 取hashCode值
// h ^ (h >>> 16) 爲第二步 高位參與運算
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
//確定hash值之後的操作就是確定在哈希桶中的位置了
//下面是 put() 方法中的一行代碼，n爲哈希桶數組長度，hash爲前一步確定的hash值
p = tab[i = (n - 1) & hash]
- 可以看到，哈希桶數組索引位置是由位運算來操作。下面是一個例子
- 圖片來自美團技術團隊在知乎上的文章：Java 8系列之重新認識HashMap
HashMap確定哈希桶數組索引位置的位移運算舉例
- 仔細想一下，數組長度減一得到的值的二進制數，前面大部分都是0，所以，可以說，Hash算法最終得到的index結果，完全取決於Key的Hashcode值的最後幾位。
- 那麼這樣的過程是不是會出現不同的key得到同一個索引位置的情況呢？
- 當計算的hash值出現了重複，就出現了地址衝突了（嚴格來收叫做碰撞）
- 這時候就需要解決衝突了。詳情請見後面小標題——解決衝突。
put 插入過程
- 具體的流程就如下圖所示（在put過程中是解決了地址衝突的），get操作自己下去看，也是類似的。
- 下面的圖片來自美團技術團隊在知乎上的文章：Java 8系列之重新認識HashMap
HashMap的put過程圖解
public V put(K key, V value) {
//這裏調用了hash()方法，拿到了Key的hash值
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;
//第二部分：拿到index對應的數組元素（節點），判斷是否爲空，爲空則直接插入
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//第三部分：節點存在，發生哈希碰撞，解決哈希碰撞
else {
Node<K,V> e; K k;
//第三部分第一小節：Key存在，則直接覆蓋Value
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則轉換爲紅黑樹進行操作
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//第三小節第二段：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;
//第四部分：鏈表中的元素數量大於閾值，則擴容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
resize 擴容機制
- 不斷的向 HashMap 中添加元素，當哈希桶數組的元素數目超過閾值，就要擴容了。
- 擴容後的 HashMap 容量是之前容量的兩倍。
- 擴容操作十分耗時，所以在使用的時候要適當的給定容量值。
- 對數組進行擴容，數組大小是不能改變的，所以這裏使用了構建新數組，然後轉移舊數組元素的方式來實現的。
- 這一點在 ArrayList 中也有體現。
- 所以，具體的流程如下：
- 排除異常情況
- 擴容2倍新建數組
- 轉移數據
- 新數組引用到table上
- 重新設置閾值
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;
}
//原索引 + oldCap
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//鏈表1存於原索引
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//鏈表2存於原索引加上原hash桶長度的偏移量
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
- 經上分析之後，可以得出：在擴容後，原數組元素被分爲了兩部分：
- 索引位置要麼不變
- 要麼動舊容量個位置
- 鏈表轉移數據的部分，分爲了兩個鏈表，通過下面的語句來判斷
if ((e.hash & oldCap) == 0) {···}
- 擴容後，若hash值新增參與運算的位=0，那麼元素在擴容後的位置=原始位置
- 擴容後，若hash值新增參與運算的位=1，那麼元素在擴容後的位置=原始位置+擴容後的舊位置。
- hash值新增參與運算的位是什麼呢？我們把hash值轉變成二進制數字，新增參與運算的位就是倒數第五位。
- 這裏面有一個非常好的設計理念，擴容後長度爲原hash表的2倍，於是把hash表分爲兩半，分爲低位和高位，如果能把原鏈表的鍵值對， 一半放在低位，一半放在高位，而且是通過e.hash & oldCap == 0來判斷，這個判斷有什麼優點呢？
舉個例子：n = 16，二進制爲10000，第5位爲1，e.hash & oldCap 是否等於0就取決於e.hash第5 位是0還是1，這就相當於有50%的概率放在新hash表低位，50%的概率放在新hash表高位。
線程安全性
- 不安全！
- 所以纔會有了
ConcurrentHashMap，它的功能和HashMap是一樣的，但它支持併發訪問。
解決衝突
- java 中 HashMap 採用的是 鏈地址法 來解決衝突的。
- 哈希碰撞： 在插入數據時，通過hash算法計算出來的index這個位置，在哈希桶數組上已經存在元素，則會出現哈希衝突（哈希碰撞更官方）。
- 發生衝突之後會解決衝突：將數據掛在初始化位置（有點問題）的鏈表後（尾插法），然後當某個結點出現過多的鏈表結點之後，就會轉換爲紅黑樹以提高效率
學完 HashMap 原理之後，我們應該解決的問題
HashMap的底層數據結構是什麼？
jdk1.7 及之前的版本是：數組 + 鏈表
jdk1.8 版本是：數組 + 鏈表 + 紅黑樹
爲什麼是紅黑樹呢？
紅黑樹是一個自平衡的二叉查找樹，也就是說紅黑樹的查找效率是非常的高，查找效率會從鏈表的o(n)降低爲o(logn)。
爲什麼不一下子把整個鏈表變爲紅黑樹呢？
1. 構造紅黑樹要比構造鏈表複雜，在鏈表的節點不多的時候，從整體的性能看來， 數組+鏈表+紅黑樹的結構可能不一定比數組+鏈表的結構性能高。
2. HashMap 頻繁的擴容，會造成底部紅黑樹不斷的進行拆分和重組，這是非常耗時的。因此，也就是鏈表長度比較長的時候轉變成紅黑樹纔會顯著提高效率。
HashMap中增刪改查操作的底部實現原理是什麼？
太多了，自己想想put過程、數據結構等
爲什麼HashMap容量一定要爲16或者2的冪呢？
HashMap 採用這種非常規設計，主要是爲了在取模和擴容時做優化，同時爲了減少hash碰撞，HashMap 定位哈希桶索引位置時，也加入了高位參與運算的過程。
長度16或者其他2的冪，Length-1的值是所有二進制位全爲1，這種情況下，index的結果等同於HashCode後幾位的值。只要輸入的HashCode本身分佈均勻，Hash算法的結果就是均勻的。
如果不爲16或者2的冪，那麼，經過hash算法之後，有些index結果出現的概率會更大，而有些index則永遠步會出現。即不符合hash算法的j均勻分佈的原則。
爲什麼負載因子默認值會是0.75呢？
在HashMap的源碼中有這樣一段註解：
* Because TreeNodes are about twice the size of regular nodes, we
* use them only when bins contain enough nodes to warrant use
* (see TREEIFY_THRESHOLD). And when they become too small (due to
* removal or resizing) they are converted back to plain bins. In
* usages with well-distributed user hashCodes, tree bins are
* rarely used. Ideally, under random hashCodes, the frequency of
* nodes in bins follows a Poisson distribution
* (http://en.wikipedia.org/wiki/Poisson_distribution) with a
* parameter of about 0.5 on average for the default resizing
* threshold of 0.75, although with a large variance because of
* resizing granularity. Ignoring variance, the expected
* occurrences of list size k are (exp(-0.5) * pow(0.5, k) /
* factorial(k)). The first values are:
*
* 0: 0.60653066
* 1: 0.30326533
* 2: 0.07581633
* 3: 0.01263606
* 4: 0.00157952
* 5: 0.00015795
* 6: 0.00001316
* 7: 0.00000094
* 8: 0.00000006
* more: less than 1 in ten million
*
大概意思就是：在理想情況下，使用隨機哈希嗎，節點出現的頻率在hash桶中遵循泊松分佈，同時給出了桶中元素的個數和概率的對照表。
從上表可以看出當桶中元素到達8個的時候，概率已經變得非常小，也就是說用0.75作爲負載因子，每個碰撞位置的鏈表長度超過8個是幾乎不可能的。
hash容器指定初始容量儘量爲2的冪次方。
HashMap負載因子爲0.75是空間和時間成本的一種折中。
HashMap是如何實現擴容的？
結合resize擴容過程思考，注意轉移數據的時候是兩個鏈表（hash表高低位）。
HashMap是如何解決hash衝突的？
鏈地址法！！！
哈希桶數組元素髮生哈希碰撞，產生鏈表，鏈表長度不小於8（數組大小不小於64），轉換爲鏈表。
HashMap爲什麼是非線程安全的？
- HashMap不是線程安全的，在多線程併發的環境下，可能會產生死鎖等問題。
- 補充一點 Hashtable 是線程安全的。還有併發的 HashMap ：ConcurrentHashMap（java5引入的）。
因爲源碼裏面方法全部都是非線程安全的呀。
可以將 HashMap 轉變爲線程安全的：
HashMap<Integer, String> hashMap1 = (HashMap<Integer, String>) Collections.synchronizedMap(hashMap);
HashMap 與 Hashtable 的區別？
- Hashtable 是java的遺留類，java4的時候被重寫了，加入了集合類。
1. HashMap線程不安全，是非synchronized的，Hashtable是線程安全的。
2. HashMap可以接受null(HashMap可以接受爲null的鍵值(key)和值(value))，而Hashtable則不行。
3. 是HashMap的迭代器(Iterator)是fail-fast迭代器，而Hashtable的enumerator迭代器不是fail-fast的。所以當有其它線程改變了HashMap的結構（增加或者移除元素），將會拋出ConcurrentModificationException，但迭代器本身的remove()方法移除元素則不會拋出ConcurrentModificationException異常。但這並不是一個一定發生的行爲，要看JVM。這條同樣也是Enumeration和Iterator的區別。
4. 由於Hashtable是線程安全的也是synchronized，所以在單線程環境下它比HashMap要慢。如果你不需要同步，只需要單一線程，那麼使用HashMap性能要好過Hashtable。
5. HashMap不能保證隨着時間的推移Map中的元素次序是不變的。
6. 繼承的父類不同、作者不同，產生時間不同。HashMap是繼承自AbstractMap類，而HashTable是繼承自Dictionary類。不過它們都實現了同時實現了Map、Cloneable（可複製）、Serializable（可序列化）這三個接口
7. 初始容量大小和每次擴充容量大小的不同。Hashtable默認的初始大小爲11，之後每次擴充，容量變爲原來的2n+1。HashMap默認的初始化大小爲16。之後每次擴充，容量變爲原來的2倍。
8. 計算hash值的方法不同。爲了得到元素的位置，首先需要根據元素的Key計算出一個hash值，然後再用這個hash值來計算得到最終的位置。Hashtable直接使用對象的hashCode。然後再使用取餘來獲得最終的位置，比較耗時。HashMap是通過位運算來進行操作的，效率高。
下面是 Hashtable 的確定索引方法：
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
該怎麼設置HashMap的閾值和負載因子呢？
個人認爲，不需要設置。只需要設置好數組容量大小就好了。
鏈接：https://www.jianshu.com/p/aacb2116c286
