什么是HashMap
HashMap在應用層的使用非常廣泛，用來儲存鍵值對。它使用哈希函數來做索引因此性能較高。同TreeMap相比，HashMap的插入、刪除、查詢時間復雜度在理想情況下達到O(1)。JDK1.8后，HashMap采用了TreeMap優化鏈表，因此極端情況下插入、刪除、查詢的效率也比線性好，達到O(lgN)。而JDK1.8以前，HashMap使用鏈表處理哈希碰撞，所以極端情況時間復雜度為O(N)。
什么情況用HashMap
當開發者想要儲存有關聯的鍵值對時，在不考慮并發安全性和有序性的前提下，應該使用HashMap。
例如:
public static class Node implements Comparable<Node>{
public Node(int v){
this.value = v;
}
public int value;
@Override
public int compareTo(Node o) {
return this.value-o.value;
}
}
public static void main(String[] args) {
Map<Node,Object> map=new HashMap<>();
map.put(new Node(6), new Object());
map.put(new Node(3), new Object());
map.put(new Node(5), new Object());
map.put(new Node(4), new Object());
map.put(new Node(1), new Object());
map.put(new Node(11), new Object());
Iterator<Node> iterator = map.keySet().iterator();
while(iterator.hasNext()){
Node n = iterator.next();
System.out.println(n.value+" , "+map.get(n));
}
}
輸出結果:
5 , java.lang.Object@33909752
11 , java.lang.Object@55f96302
1 , java.lang.Object@3d4eac69
6 , java.lang.Object@42a57993
3 , java.lang.Object@75b84c92
4 , java.lang.Object@6bc7c054
HashMap運行插入的鍵是null，如果鍵是null，其哈希值為0，所以null型鍵值對會插入到數組的首個位置。
HashMap內部實現
基于JDK1.8分析
HashMap內部依賴數組、鏈表、紅黑樹實現。
數組/鏈表節點
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
}
HashMap將插入的鍵值對封裝在Node對象中，每個Node對象含有hash值，鍵對象key，值對象value。當哈希值沖突后，新增的Node會被next變量指向，組成鏈表。當該鏈表的長度超過8，將其轉換為紅黑樹節點。
紅黑樹節點
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;
}
容量及擴容
HashMap構造方法并沒有對內部的table數組初始化，可能是為了防止未使用的情況下浪費內存。當初次執行插入，如果數組為空就會初次調用擴容方法resize()創建table數組。
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 (++size > threshold)
resize();
}
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length; //初始長度為0
int oldThr = threshold; //如果HashMap構造方指定了初始長度和加載因子，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); //默認臨界值
}
}
如果未指定HashMap的構造方法參數，數組初始長度為DEFAULT_INITIAL_CAPACITY（16），加載因子為DEFAULT_LOAD_FACTOR(0.75)。開發者也可以通過HashMap的構造方法指定初始長度和加載因子。
HashMap的容量超過當前數組長度*加載因子，就會執行resize()算法，該算法將創建一個新的數組，長度是原來的兩倍（舊的長度左移一位），并且將原來的HashMap數組的節點轉換到新的數組。同時threshold變量也會是原來的兩倍，該變量用來判斷HashMap在插入后是否應該擴容。
** 疑問：為什么擴容要將原長度左移一位呢? 因為性能問題？**
插入算法
取哈希值
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
首先調用Object的hashCode()方法算出key的哈希值，該方法在native層實現。接著將key的哈希值(int型32位)無符號右移16位，即取它的高16位返回,右移后高16位變成0，原高16位移動到低16位。
取數組中的位置
再來看具體的插入putVal方法:
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);
這里n是table數組的長度，hash是key的哈希值經過高16位轉低16位的int值。
這里計算節點在table數組的位置的算法是:i = (n - 1) & hash，將數組長度減1后與運算hash。這個算法就很巧妙了，記得上面說過數組的長度一定是2的冪，即使初始長度非2的冪也會強制轉換為2的冪:
this.threshold = tableSizeFor(initialCapacity);
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;
}
假設傳入cap=5，最后輸出長度為8。加入傳入cap=9，最后輸出長度為16。所以n-1的二進制形式分別是111,1111。
** 用hash與(n-1)做位置運算相比%運算更高效，這可能就是HashMap數組長度為2的冪的原因吧。并且這種巧妙的設計也能保證位置i不會超過數組長度。**
非沖突的情況
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
return new Node<>(hash, key, value, next);
}
根據key算出hash值后，再通過** “(n-1)&hash” **算出鍵值對在數組中對應的位置，如果table[i]為空直接將鍵值對封裝到Node插入table[i]。
沖突的情況
首個位置的鍵與新插入的鍵相等
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
當table[i]非空，且key==table[i].key 或者 key非空，key.equals(table[i],key)。說明table[i]上的節點的鍵key等同于新插入的鍵，這種情況下令新插入的節點為table[i]。下面會將table[i]中的value替換為新插入的value。
首個位置是紅黑樹的節點
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
上面說到，如果哈希表發生了哈希碰撞，沖突的節點會插入到以table[i]為鏈表頭的尾部。如果該鏈表長度超過8，會轉換成紅黑樹。因此table[i]既可能是鏈表頭，也可能是紅黑樹的根部。
如果tablei是紅黑樹的節點，說明該hash值沖突的節點沖過了8個，將新的鍵值對插入紅黑樹。
首個位置是鏈表節點
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) { @1
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash); @3
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
@2
break;
p = e;
}
@1 如果遍歷到鏈表的末尾，說明遍歷的過程中未找到key相等的節點，將鍵值對插入末尾
@2 如果遍歷鏈表的過程中，存在哈希值一致，引用相等或equals相等的節點，終止遍歷，新鍵值對的值會替換這個節點上原來的值。
@3 在鏈表末尾插入新節點后，鏈表的長度達到8，此時方法treeifyBin(tab, hash)將鏈表轉換為紅黑樹
替換原節點中的Value
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
對于已經在鏈表或紅黑樹存在的節點，只會替換原Value就返回。
插入后的擴容
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
在前面已經描述過，當HashMap的size超過了 長度*負載因子，就會執行resize()方法擴容，將原table數組長度擴大兩倍。
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; @1
else if (e instanceof TreeNode) @2
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order @3
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;
}
}
}
}
}
這段代碼將原數組中的元素插入到新數組中，具體表現為:
@1 將非鏈表非紅黑樹的節點計算新位置后重新插入新數組。
@2 將原紅黑樹插入新的數組
@3 將原鏈表插入新的數組
這里要注意的是，擴容后(n-1)的值在高一位多了1，因此原來的鏈表和紅黑樹的節點的位置可能出現高一位多了1，所以不能簡單的直接將頭節點移動到新數組,需要重新計算位置。而哈希值不需要重新計算，所以這可能就是** (n-1)&hash **這個算法的好處吧。
取出算法
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
取出算法其實就是插入算法的逆向過程，你可能直接從table[i]中取走鍵值對，也可能是紅黑樹或者鏈表中的一個節點。
要注意的是只滿足equlas相等并不能有效取出元素，還必須滿足哈希值相等，所以要考慮重寫key的hashCode()方法。
HashMap小結
- JDK1.8以后用紅黑樹對HashMap的鏈表做了優化，因此使得HashMap的最差性能從O(n)提升到O(lgn)。
- 擴容是一件很耗費性能和內存的事情，除了要創建新數組，還要將原數組中的鏈表或紅黑樹重新計算位置（不重新計算哈希值），然后插入新的數組。
- 如果HashMap創建時就知道對面的是多大容量的數據，可以指定初始容量和負載因子。
- HashMap和TreeMap都是非線程安全的，建議使用ConcurrentHashMap處理并發安全問題。Hashtable的并非像ConcurrentHashMap對數組的每個位置加鎖，而是對操作加鎖，性能較差。另外Collections.synchronizedMap(map)這種方法也是在Map對象的方法上裝飾了synchronized關鍵字，因此同Hashtable性能較差。
- LinkedHashMap繼承于HashMap，替HashMap完成了輸入順序的記錄功能，所以要想實現像輸出同輸入順序一致，應該使用LinkedHashMap。
