HashMap是我們最常用的類之一，它實現了hash演算法，雖然使用很簡單，但是其實現有很多值得研究的地方。

HashMap儲存的是key-value形式的鍵值對，這個鍵值對在實現中使用一個靜態內部類Entry來表示，它儲存了key、value、hash值、以及在hash衝突時連結串列中下一個元素的引用。

HashMap底層實現使用了一個數組來儲存元素。它的初始容量預設是16，而且必須容量必須是2的整數次冪，最大容量是1<<30（10.7億+），同時還使用一個載入因子（load factor）來控制這個map的這個hash表的擴容，預設為0.75，即當容量達到初始容量3/4時會擴容（當然不只這樣，後面會說明）。

在往HashMap中新增元素時，會計算key的hashCode，然後基於這個hashCode和陣列大小來確定它在陣列中的儲存位置，當遇到hash衝突時，會以連結串列的形式儲存在陣列中。

下面具體看看原始碼，首先看構造方法

    public HashMap(int initialCapacity, float loadFactor) {
    // 初始容量不能小於0，否則會丟擲異常
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        // 控制初始容量不能大於最大容量1<<30
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        // 檢查載入因子的合法性，不能小於0，且必須是數值
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);

        this.loadFactor = loadFactor;
        threshold = initialCapacity;
        // 這個init方法是留給子類擴充套件
        init();
    }
 

可以看到在建立HashMap時，並不分配記憶體空間，而是在真正往map中新增資料時才會分配，可以從put方法中看到：

    public V put(K key, V value) {
        // 建立時未分配空間，所以檢查如果還是空表的話，就分配記憶體空間
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        // 對null的key進行的特殊處理
        if (key == null)
            return putForNullKey(value);
        // 計算key的hashCode
        int hash = hash(key);
        // 根據hashCode和當前容量來確定元素在hash表中的位置，即hash桶的位置
        int i = indexFor(hash, table.length);
        // 檢查key是否已經存在，如果已經存在，則替換舊值為新值，並返回舊值
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            // 這裡可以看到是根據hashCode和equals方法來判斷一個key是否已經存在
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        // 增加map的修改次數，這用於實現fail-fast機制
        modCount++;
        // 真正把元素新增到hash表中指定的索引位置處理（也叫hash桶）
        addEntry(hash, key, value, i);
        // 返回null表示key之前不存在
        return null;
    }

    void addEntry(int hash, K key, V value, int bucketIndex) {
    // 判斷是否需要擴容，當前容量達到闕值，並且產生了hash衝突（指定hash桶已經有元素存在）
        if ((size >= threshold) && (null != table[bucketIndex])) {
            // 容量擴充套件為之前的2倍
            resize(2 * table.length);
            hash = (null != key) ? hash(key) : 0;
            // 重新計算儲存的hash桶位置
            bucketIndex = indexFor(hash, table.length);
        }
        // 建立Entry並存儲到hash表中
        createEntry(hash, key, value, bucketIndex);
    }

    void createEntry(int hash, K key, V value, int bucketIndex) {
    // 取出之前已經存在的元素
        Entry<K,V> e = table[bucketIndex];
        // 把新元素放到連結串列的開頭，即讓新元素的next引用指向之前已經存在的元素
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        // 修改元素計數
        size++;
    }
 

從程式碼中可以看到，擴容需要滿足以下兩個條件：

1. 達到載入因子指定的闕值
2. put當前值時發生hash衝突（即當前桶的位置已經存在有元素了）

只是當前容器中key value數量超過闕值是不會進行擴容的。就是說，比如初始容量為16，當達到闕值以前發生大量的hash衝突，而後新增的元素又很少發生hash衝突，那麼有可能key value的數量超過16*0.75=12甚至超過16都不進行擴容，所以hash演算法必須保證分佈均勻，儘量減少hash衝突。

上面是新增元素的實現，這裡再看看它是如何初始化並分配記憶體的：

    private void inflateTable(int toSize) {
        // 保證容量是2的整數次冪
        int capacity = roundUpToPowerOf2(toSize);
        // 在初始化的時候就把擴容的闕值計算好並儲存，避免每次都重新計算
        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        // 這裡才會真正的分配記憶體
        table = new Entry[capacity];
        // 初始化hash種子
        initHashSeedAsNeeded(capacity);
    }
    /**
     * 保證容量是2的整數次冪，並且不超過最大容量。
     * 比如：傳入的是15，值變成16，傳入的是17，則會變成32，
     * 即大於當前值且與最接近2的整數次冪的數
     */
    private static int roundUpToPowerOf2(int number) {
        // 保證容量是2的整數次冪，並且不超過最大容量
        return number >= MAXIMUM_CAPACITY
                ? MAXIMUM_CAPACITY
                : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
    }

對null key的特殊處理：

    private V putForNullKey(V value) {
    // 如果已經存在，則替換舊值
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        // 增加map的修改次數，這用於實現fail-fast機制
        modCount++;
        // null key的hashCode固定為0，並且桶的位置也固定為0
        addEntry(0, null, value, 0);
        return null;
    }

再來看如何確定非null key的位置

    static int indexFor(int h, int length) {
        return h & (length-1);
    }

h是key的hashCode，length是當前hash表的最大長度，h & (length-1)與h % length等價，只是前者使用位運算，而位運算比取模運算速度更快。這裡為什麼可以用&運算代替取模運算呢？因為length是2的整數次冪，而它減1，低位正好全是1，與另一個數進行&運算，結果肯定不會超過length，與%運算的效果一樣。如果length不是2的整數次冪，那麼是不能這樣做的，所以這裡運用的非常巧妙。

下面看看最核心的生成hashCode的hash方法：

    final int hash(Object k) {
        int h = hashSeed;
        if (0 != h && k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }
        // 呼叫key的hashCode()方法得到hashCode
        h ^= k.hashCode();

        // 對hashCode進行一系列的位移與異或運算並把結果作為hashCode返回
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

這裡為什麼要進行這一系列的位移與異或運算呢？主要是經過它這裡的運算之後，能夠使這個hashCode中的bit 0和1均勻分佈，從而減少hash衝突，從而提高整個HashMap的效率。

擴容時的rehash：

    void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
        // 重新建立底層陣列
        Entry[] newTable = new Entry[newCapacity];
        // 對已經存在的元素進行重新hash放到新的hash桶中
        transfer(newTable, initHashSeedAsNeeded(newCapacity));
        table = newTable;
        // 更新擴容闕值
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }

    void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        for (Entry<K,V> e : table) {
            while(null != e) {
                Entry<K,V> next = e.next;
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity);
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
    }

由於hash表長度變化了，所以對於已經存在的元素，需要重新計算hashCode並放到新的hash桶中。這是一個比較耗時的操作，所以在建立HashMap時，如果對資料量有個預期值，那麼，應該設定更合適的初始容量，以避免新增資料的過程中不斷的擴容造成的效能損失。

下面再來看看get操作

    public V get(Object key) {
    // null key進行特殊操作
        if (key == null)
            return getForNullKey();
        // 獲取key對應的Entry
        Entry<K,V> entry = getEntry(key);
        // 如果存在則返回key對應的值，不存在則返回null
        return null == entry ? null : entry.getValue();
    }

    final Entry<K,V> getEntry(Object key) {
    // size為0表示沒有元素，所以直接返回null
        if (size == 0) {
            return null;
        }
        // 獲取key的hashCode
        int hash = (key == null) ? 0 : hash(key);
        // 獲取key對應的hash桶中的元素，並對連結串列進行迭代返回相應的value
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            // 根據hashCode和equalse（）方法來確定key
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        // 如果不存在，返回null
        return null;
    }

對於載入因子，預設為0.75，這是一個折衷的值， 我們可以通過構造方法來改變這個值，但是需要注意，載入因子越大，查詢資料的開銷可能越大。因為載入因子越大，意味著map中存放的元素越多，所以hash衝突的可能性越大，根據hashCode計算出的hash桶的位置相同，則儲存為連結串列，而連結串列的查詢操作會遍歷整個連結串列，所以查詢效率不高。而在get和put時都要查詢元素，所以提高查詢效率就提高了hashmap的效率。這是一種用空間換取時間的策略。

為什麼HashMap很高效呢？HashMap通過以下幾點保證了它的效率：

• 高效的hash演算法，使其不易產生hash衝突
• 基於陣列儲存，實現了元素的快速存取
• 可通過載入因子，使用空間換取時間