HashMap的實現原理筆記

序

HashMap是Java中經常使用的Map接口的實現類，由於在平常工做中很是頻繁的出現，因此在大部分的Java面試中都會問幾個關於HashMap的問題。掌握HashMap的實現原理，已是Java程序員的基礎操做了。

Map接口

映射（Map）是一種用於存放鍵/值對的數據結構。若是提供了鍵，就能直接找到相對應的值。HashMap（哈希映射）是Map接口的一個實現類，主要使用哈希來實現鍵與值的映射。

定義。映射是一種用於存放鍵/值對的數據結構，主要支持兩種操做：插入（put），即將一組新的鍵值對存入映射中；查找（get），即根據給定的鍵獲得相應的值。

HashMap的底層數據結構

HashMap的底層是用散列表實現的，散列表是一種用數組來存儲鍵值對的數據結構，它使用一個散列函數將鍵轉換成數組的一個索引而後存儲值。不過會有不一樣的鍵被散列成同個索引的狀況出現，這叫作碰撞衝突。HashMap用拉鍊法來解決這個問題，即散列表數組中的每一個元素都指向一條鏈表，鏈表中的每一個節點都存儲了被散列到這個索引的鍵值對。

HashMap的散列函數

根據散列表的定義咱們知道，想要弄清楚HashMap的實現，咱們首先須要知道HashMap的散列函數是怎麼實現的，即HashMap是如何將一個鍵映射到數組的索引的。

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
複製代碼

上面就是HashMap的散列函數源碼了，能夠看到若是鍵爲null的話它的索引固定爲0，即HashMap是支持使用null做爲鍵的。若是鍵不爲null就用Java對象都有的hashCode方法得到一個哈希值，並將這個哈希值的低16位與高16位作異或處理，高16位不變。

這裏有個問題就是爲何不直接用鍵的hashcode，而要將hashcode的低16位與高16位作異或處理？這裏是由於有三個前提：

• int有32位
• HashMap的數組長度都是2的冪
• 獲取數組索引須要將鍵的哈希值和數組長度-1作一個與操做（&）獲得，即tab[(n - 1) & hash]

首先由於HashMap的數組長度都是2的冪，（n - 1）的高16位都是0，因此只有鍵的低16位參與索引運算。若是直接用鍵的hashcode的話，就會有不少碰撞衝突，因此用這種方法使得hashcoede的高16位也參與到索引的運算中來。下面是字符串「1234」在數組長度爲16的索引運算過程：

public static void main(String[] args) {
    int hashcode = "1234".hashCode();
    System.out.println(Integer.toBinaryString(hashcode));
    // 輸出爲 10111 0000100001000010
    System.out.println(Integer.toBinaryString(hashcode >>> 16));
    // 輸出爲 10111
    System.out.println(Integer.toBinaryString(hashcode ^ (hashcode >>> 16)));
    // 輸出爲 10111 0000100001010101
    System.out.println(Integer.toBinaryString(16 - 1));
    // 輸出爲 1111
    System.out.println(Integer.toBinaryString((16 - 1) & (hashcode ^ (hashcode >>> 16))));
    // 輸出爲 101
}
複製代碼

碰撞衝突

雖然HashMap對散列函數作了不少優化，可是碰撞衝突仍是不可避免的會出現。爲了解決這個問題HashMap使用了拉鍊法，使用鏈表來存儲碰撞衝突的鍵值對。並在JDK 8中進行了優化，當鏈表長度到達某個指定值時HashMap會自動將鏈表優化爲紅黑樹。頻繁碰撞衝突還多是由於數組長度不夠的緣由，HashMap還會根據鍵值對的數量進行自動擴容。

自動擴容

在講HashMap的自動擴容前，先來看看HashMap有哪些相關的屬性：

• Node<K,V>[] table; 存放鍵值對的數組
• int size; 已存放鍵值對的數量
• int threshold; 當鍵值對的數量等於這個值的時候HashMap將進行擴容，值等於數組長度 * loadFactor
• final float loadFactor; 負載因子，用於計算threshold的值，默認值爲0.75
• static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 數組長度的默認值16

根據這些屬性能夠知道，HashMap的自動擴容會根據數組長度和負載因子的積獲得一個threshold的值，當鍵值對的數量等於threshold時就會開始擴容，下面是擴容的源碼。大概過程是新建一個長度爲舊數組兩倍的新數組，並將原有的鍵值對都從新映射到新數組上。

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        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)
                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;
        @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;
                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的實現原理，特別重點寫了不少關於散列函數的理解，並無按照源碼一行行的去理解。之因此這樣是由於寫這篇的動力主要來源於面試……而面試則只要講下原理就能夠了，並不須要把源碼背下來。以前看HashMap的時候對散列函數都是跳過去的，只知道是用來計算鍵的hash，不知道里面的原理。其實還有鏈表轉紅黑樹的地方沒有弄清楚，主要是紅黑樹不怎麼理解，基礎的重要性體現了出來。

個人博客