細說java.util.HashMap，java.util.hashmap

細說java.util.HashMap，java.util.hashmap

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++;    }

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

只是當前容器中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衝突
• 基於數組儲存，實現了元素的快速存取
• 可通過載入因子，使用空間換取時間

著作權聲明：本文為博主原創文章，未經博主允許不得轉載。