一 hash表的介紹
非hash表的特點：關鍵字在表中的位置和它之間不存在一個確定的關係，查詢的過程為給定值一次和各個關鍵進行比較，查詢的效率取決於和給定值進行比較的次數。
雜湊表的特點：關鍵字在表中位置和它之間存在一種確定的關係

雜湊函式：翻譯為雜湊，就是把任意長度的輸入，通過雜湊函式演算法，變成固定長度的輸出，該輸出就是雜湊值，這種轉換是一種壓縮對映，雜湊值的空間通常遠小於輸入的空間，不同的輸入有可能相同的輸出，所以不能用雜湊值來唯一確定輸入值。一般情況下，需要在關鍵字與它在表中的儲存位置之間建立一個函式，以f（key）作為關鍵字為key記錄在表中的位置，通常稱這個函式f（key）為雜湊函式。
簡單來說就是將任意長度的訊息壓縮到固定長度的訊息摘要的函式。

HashMap概述

HashMap是基於雜湊表的Map介面的非同步實現。此實現提供所有可選的對映操作，並允許使用null值和null鍵。此類不保證對映的順序，特別是它不保證該順序恆久不變。

HashMap的資料結構

在Java程式語言中，最基本的結構就是兩種，一個是陣列，另外一個是模擬指標（引用），所有的資料結構都可以用這兩個基本結構來構造的，HashMap也不例外。HashMap實際上是一個“連結串列雜湊”的資料結構，即陣列和連結串列的結構，但是在jdk1.8裡
加入了紅黑樹的實現，當連結串列的長度大於8時，轉換為紅黑樹的結構。

這裡寫圖片描述

從上圖中可以看出，java中HashMap採用了鏈地址法。鏈地址法，簡單來說，就是陣列加連結串列的結合。在每個陣列元素上都一個連結串列結構，當資料被Hash後，得到陣列下標，把資料放在對應下標元素的連結串列上。

 */
static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;//用於定位陣列索引的位置
    final K key;
    V value;
    Node<K,V> next;//連結串列的下一個Node

    Node(int hash, K key, V value, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }
 

Node是HashMap的一個內部類，實現了Map.Entry介面，本質是就是一個對映(鍵值對)。

有時兩個key會定位到相同的位置，表示發生了Hash碰撞。當然Hash演算法計算結果越分散均勻，Hash碰撞的概率就越小，map的存取效率就會越高。

HashMap類中有一個非常重要的欄位，就是 Node[] table，即雜湊桶陣列，明顯它是一個Node的陣列。

如果雜湊桶陣列很大，即使較差的Hash演算法也會比較分散，如果雜湊桶陣列陣列很小，即使好的Hash演算法也會出現較多碰撞，所以就需要在空間成本和時間成本之間權衡，其實就是在根據實際情況確定雜湊桶陣列的大小，並在此基礎上設計好的hash演算法減少Hash碰撞。那麼通過什麼方式來控制map使得Hash碰撞的概率又小，雜湊桶陣列（Node[] table）佔用空間又少呢？答案就是好的Hash演算法和擴容機制。

在理解Hash和擴容流程之前，我們得先了解下HashMap的幾個欄位。從HashMap的預設建構函式原始碼可知，建構函式就是對下面幾個欄位進行初始化，原始碼如下：

int threshold; // 所能容納的key-value對極限
final float loadFactor; // 負載因子
int modCount;
int size;
首先，Node[] table的初始化長度length(預設值是16)，Load factor為負載因子(預設值是0.75)，threshold是HashMap所能容納的最大資料量的Node(鍵值對)個數。threshold = length * Load factor。也就是說，在陣列定義好長度之後，負載因子越大，所能容納的鍵值對個數越多。

結合負載因子的定義公式可知，threshold就是在此Load factor和length(陣列長度)對應下允許的最大元素數目，超過這個數目就重新resize(擴容)，擴容後的HashMap容量是之前容量的兩倍。預設的負載因子0.75是對空間和時間效率的一個平衡選擇，建議大家不要修改，除非在時間和空間比較特殊的情況下，如果記憶體空間很多而又對時間效率要求很高，可以降低負載因子Load factor的值；相反，如果記憶體空間緊張而對時間效率要求不高，可以增加負載因子loadFactor的值，這個值可以大於1。

size這個欄位其實很好理解，就是HashMap中實際存在的鍵值對數量。注意和table的長度length、容納最大鍵值對數量threshold的區別。而modCount欄位主要用來記錄HashMap內部結構發生變化的次數，主要用於迭代的快速失敗。強調一點，內部結構發生變化指的是結構發生變化，例如put新鍵值對，但是某個key對應的value值被覆蓋不屬於結構變化。

在HashMap中，雜湊桶陣列table的長度length大小必須為2的n次方(一定是合數)，這是一種非常規的設計，常規的設計是把桶的大小設計為素數。相對來說素數導致衝突的概率要小於合數，具體證明可以參考http://blog.csdn.net/liuqiyao_01/article/details/14475159，Hashtable初始化桶大小為11，就是桶大小設計為素數的應用（Hashtable擴容後不能保證還是素數）。HashMap採用這種非常規設計，主要是為了在取模和擴容時做優化，同時為了減少衝突，HashMap定位雜湊桶索引位置時，也加入了高位參與運算的過程。

這裡存在一個問題，即使負載因子和Hash演算法設計的再合理，也免不了會出現拉鍊過長的情況，一旦出現拉鍊過長，則會嚴重影響HashMap的效能。於是，在JDK1.8版本中，對資料結構做了進一步的優化，引入了紅黑樹。而當連結串列長度太長（預設超過8）時，連結串列就轉換為紅黑樹，利用紅黑樹快速增刪改查的特點提高HashMap的效能，其中會用到紅黑樹的插入、刪除、查詢等演算法

確定雜湊桶陣列索引位置

程式碼實現：

//方法一：
static final int hash(Object key) { //jdk1.8 & jdk1.7
int h;
// h = key.hashCode() 為第一步 取hashCode值
// h ^ (h >>> 16) 為第二步 高位參與運算
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
//方法二：
static int indexFor(int h, int length) { //jdk1.7的原始碼，jdk1.8沒有這個方法，但是實現原理一樣的
return h & (length-1); //第三步 取模運算
}

這裡的Hash演算法本質上就是三步：取key的hashCode值、高位運算、取模運算。

對於任意給定的物件，只要它的hashCode()返回值相同，那麼程式呼叫方法一所計算得到的Hash碼值總是相同的。我們首先想到的就是把hash值對陣列長度取模運算，這樣一來，元素的分佈相對來說是比較均勻的。但是，模運算的消耗還是比較大的，在HashMap中是這樣做的：呼叫方法二來計算該物件應該儲存在table陣列的哪個索引處。

這個方法非常巧妙，它通過h & (table.length -1)來得到該物件的儲存位，而HashMap底層陣列的長度總是2的n次方，這是HashMap在速度上的優化。當length總是2的n次方時，h& (length-1)運算等價於對length取模，也就是h%length，但是&比%具有更高的效率。

在JDK1.8的實現中，優化了高位運算的演算法，通過hashCode()的高16位異或低16位實現的：(h = k.hashCode()) ^ (h >>> 16)，主要是從速度、功效、質量來考慮的，這麼做可以在陣列table的length比較小的時候，也能保證考慮到高低Bit都參與到Hash的計算中，同時不會有太大的開銷。

下面舉例說明下，n為table的長度。

這裡寫圖片描述

HashMap的put方法實現

put函式大致的思路為：

對key的hashCode()做hash，然後再計算index;
如果沒碰撞直接放到bucket裡；
如果碰撞了，以連結串列的形式存在buckets後；
如果碰撞導致連結串列過長(大於等於TREEIFY_THRESHOLD)，就把連結串列轉換成紅黑樹；
如果節點已經存在就替換old value(保證key的唯一性)
如果bucket滿了(超過load factor*current capacity)，就要resize。
具體程式碼實現如下：

public V put(K key, V value) {

    return putVal(hash(key), key, value, false, true);
}
/**
*生成hash的方法
*/
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;
    //判斷table是否為空，
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;//建立一個新的table陣列，並且獲取該陣列的長度
    //根據鍵值key計算hash值得到插入的陣列索引i，如果table[i]==null，直接新建節點新增   
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {//如果對應的節點存在
        Node<K,V> e; K k;
        //判斷table[i]的首個元素是否和key一樣，如果相同直接覆蓋value
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        //判斷table[i] 是否為treeNode，即table[i] 是否是紅黑樹，如果是紅黑樹，則直接在樹中插入鍵值對
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
       // 該鏈為連結串列
        else {
        //遍歷table[i]，判斷連結串列長度是否大於TREEIFY_THRESHOLD(預設值為8)，大於8的話把連結串列轉換為紅黑樹，在紅黑樹中執行插入操作，否則進行連結串列的插入操作；遍歷過程中若發現key已經存在直接覆蓋value即可；
            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;
                }
                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是否超多了最大容量threshold，如果超過，進行擴容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

HashMap的get方法實現

思路如下：

bucket裡的第一個節點，直接命中；
如果有衝突，則通過key.equals(k)去查詢對應的entry
若為樹，則在樹中通過key.equals(k)查詢，O(logn)；
若為連結串列，則在連結串列中通過key.equals(k)查詢，O(n)。
public V get(Object key) {
Node