HashMap的數據結構
HashMap是數組+鏈表+紅黑樹（JDK1.8增加了紅黑樹部分）實現的，他的底層結構是一個數組，而數組的元素是一個單向鏈表。
HashMap默認初始化的是一個長度為16位的數組，每個數組儲存的元素代表的是每一個鏈表的頭結點。在jdk1.8中，當HashMap不斷地插入元素，導致鏈表太長時，會將鏈表轉換為紅黑樹。
Node<K,V>
Node是HashMap的一個內部類，實現了Map.Entry接口，本質就是一個存儲鍵值對的鏈表。
具體如下：
static class Node<K,V> implements Map.Entry<K,V> { final int hash;//用來定位數組索引位置final K key; V value; Node<K,V> next;//鏈表的下一個nodeNode(int hash, K key, V value, Node<K,V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; }
....
}
Hash算法
通過Hash算法，對key計算出數組下標，把數據放在對應下標元素的鏈表上。
Hash算法：通過Key進行Hash的計算，就可以獲取Key對應的HashCode。如果出現了重復的hashCode，就稱作碰撞。
如果發生了碰撞事件，那么意味這數組的一個位置要插入兩個或者多個元素，這個時候數組上面掛的鏈表起作用了，鏈表會將數組某個節點上多出的元素按照尾插法(jdk1.7及以前為頭差法)的方式添加。
Hash算法本質上就是三步：取key的hashCode值、高位運算? 、取模運算。
位運算接近底層，速度較快。
Node<K,V>[] table
即哈希桶數組，明顯它是一個Node的數組。
如果哈希桶數組很大，即使較差的Hash算法也會比較分散，如果哈希桶數組數組很小，即使好的Hash算法也會出現較多碰撞，所以就需要在空間成本和時間成本之間權衡，其實就是在根據實際情況確定哈希桶數組的大小，並在此基礎上設計好的hash算法減少Hash碰撞。那么通過什么方式來控制map使得Hash碰撞的概率又小，哈希桶數組（Node[] table）占用空間又少呢？答案就是好的Hash算法和擴容機制。
Node[] table的初始化長度length(默認值是16)，Load factor為負載因子(默認值是0.75)，threshold是HashMap所能容納的最大數據量的Node(鍵值對)個數。threshold = length * Load factor。也就是說，在數組定義好長度之后，負載因子越大，所能容納的鍵值對個數越多。
結合負載因子的定義公式可知，threshold就是在此Load factor和length(數組長度)對應下允許的最大元素數目，超過這個數目就重新resize(擴容)。
HashMap如何擴容？
擴容(resize)就是重新計算容量，向HashMap對象里不停的添加元素，而HashMap對象內部的數組無法裝載更多的元素時，對象就需要擴大數組的長度，以便能裝入更多的元素。當然Java里的數組是無法自動擴容的，方法是使用一個新的數組代替已有的容量小的數組。 擴容后的HashMap容量是之前容量的兩倍。
final Node<K,V>[] resize() { Node<K,V>[] oldTab = table; //Capcity是指容量 int oldCap = (oldTab == null) ? 0 : oldTab.length; //Threshold是所能存儲的最大數量 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) //存儲的最大數量Threshold翻倍 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; //創建新的Node數組 @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; // oldTab[j]表示原數組上的元素，也就是鏈表頭節點或紅黑樹 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; } 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; } } } } } return newTab; }
HashMap插入數據：
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); }
首先要計算key的hashCode()：
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }
插入數據的過程如下：
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; //如果node[]數組為空，就先擴容 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; //計算index，並對null做處理 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; } 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; }
如何保證key的唯一性 / 保證key不重復？
如果兩個key的hashCode相等，並且通過equals比較key也相等，那么視為相等的key，這樣就只覆蓋原來key對應的value，而不產生重復的key。
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p;
線程安全性
在多線程使用場景中，應該盡量避免使用線程不安全的HashMap，而使用線程安全的ConcurrentHashMap。
其他：
1.注意hashCode()和hash()算法的區別。。
定位hash槽是HashMap自己實現的hash()函數。
hashcode()是key對象的類覆寫的Object中的方法。
先用hash(key)找到hash槽(也就是數組下標)，如果槽上沒值，直接放上去；如果有值，再判斷key是否為同一個對象（這里用的equals方法，間接使用了hashcode）,如果是就替代value，如果否則加到鏈表中。
參考博客：