在前文中介紹了HashMap中的重要元素，現在萬事俱備，需要刨根問底看看實現了。HashMap的增刪改查，都離不開元素查詢。查詢分兩部分，一是確定元素在table中的下標，二是確定以指定下標元素為首的具體位置。可以抽象理解為二維陣列，第一個通過雜湊函式得來，第二個下標則是連結串列或紅黑樹來得到，下面分別來說。

一 雜湊函式

說到HashMap，最值得引起注意的自然是接近常數級別的操作速度，大家也都知道是利用雜湊表來實現。這裡面就涉及到幾個問題：

1 如何計算雜湊；

2 如何設定雜湊表；

3 雜湊衝突後的處理方式。

首先是雜湊函式，HashMap中最關鍵的函式之一。官方給的註釋也比較詳細。先簡單說一下演算法的實現。計算雜湊是針對HashMap中節點Node<Key,Value>中的Key進行。每個物件都有各自的hashcode方法，計算其雜湊值，直接用這個雜湊值，再對雜湊表長度取餘不可以嗎，簡單高效。答案是可以，但是這樣雜湊碰撞比較厲害，這樣將大大降低HashMap的速度，也浪費空間。

目前使用的方法是，使用算出來的雜湊值高16位與低16位相亦或，按照官方註釋：這是速度，通用性，bit位均勻分佈的折中。這裡的位運算和移位運算速度都很快，在不同平臺上都能找到直接指令操作，同時保留了高位和地位的特性。

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

雜湊函式不能單獨來看。上一篇中我們說到，HashMap的初始大小DEFAULT_INITIAL_CAPACITY是為16，計算出來的雜湊值肯定是不可能全塞進去的，如何確定一個Key究竟應該放到哪個下標中呢？

    int index = (length - 1) & hash；

方法是表長度減一與雜湊值相與。這裡又引出了另外一個問題，HashMap的長度設定，選擇比初始值大的最小的2的正整數次冪，計算方法如下。

    /**
     * Returns a power of two size for the given target capacity.
     */
    static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }
 

 這個方法如何計算出2的N次冪呢？2的N次冪是最高bit位為1，其他位為0的正整數，那麼2的N次冪減一就是最高位變0，後面的都變成1。為了達成這個目的，這個演算法首先計算了2的N次冪減一。一個正整數最高bit位肯定為1，右移一位相或後，最高兩位都為1，再右移兩位後與原數相與，最高四位都為1，以此類推。因為int最多也就32位，這種方式保證了最後所有位都為1，加一後得到2的N次冪。有一個問題，為什麼剛開始的時候要減一呢？是為了防止一開始就是個2的N次冪，這樣就對不上了。這是一個很巧妙的演算法。

再回到上面這個int index = (length - 1) & hash 計算下標的演算法。有了上面的分析，很容易得到，length-1是2的N次冪減一，除最高位外都為1，用這個數與雜湊值相與，實際上就是取雜湊位元位上的值。注意之前已經說了，雜湊算出來的是高16位與低16位相亦，保留了高低位的特性，這樣一來就能有效利用元素的雜湊進行區分同時加快計算速度。

二 位置查詢

通過上面的雜湊函式和下標函式，可以準確找到元素所在下標。接下來就是找到具體所在位置。前面說到了，HashMap衝突後的解決方式有兩種，衝突數量少時用連結串列，數量多時用紅黑樹。下面就分別來看這兩種不同方式的查詢。

    /**
     * Implements Map.get and related methods.
     *
     * @param hash hash for key
     * @param key the key
     * @return the node, or null if none
     */
    final Node<K,V> getNode(int hash, Object key) {
        // 結點表
        Node<K,V>[] tab;
        // 首結點，臨時結點，表長，Key臨時變數
        Node<K,V> first, e; int n; K k;
        // 查詢下標
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            // 先看首元素是否匹配
            if (first.hash == hash && 
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            // 按紅黑樹查詢
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                // 按單向連結串列查詢
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

在上面的程式碼中，基本註釋很清楚了，連結串列查詢就是順序查詢，時間複雜度是O(n)。按紅黑樹查詢的方式如下所示。

        /**
         * Calls find for root node.
         */
        final TreeNode<K,V> getTreeNode(int h, Object k) {
            return ((parent != null) ? root() : this).find(h, k, null);
        }        


        /**
         * Finds the node starting at root p with the given hash and key.
         * The kc argument caches comparableClassFor(key) upon first use
         * comparing keys.
         */
        final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
            TreeNode<K,V> p = this;
            do {
                int ph, dir; K pk;
                TreeNode<K,V> pl = p.left, pr = p.right, q;
                if ((ph = p.hash) > h)
                    p = pl;
                else if (ph < h)
                    p = pr;
                else if ((pk = p.key) == k || (k != null && k.equals(pk)))
                    return p;
                else if (pl == null)
                    p = pr;
                else if (pr == null)
                    p = pl;
                else if ((kc != null ||
                          (kc = comparableClassFor(k)) != null) &&
                         (dir = compareComparables(kc, k, pk)) != 0)
                    p = (dir < 0) ? pl : pr;
                else if ((q = pr.find(h, k, kc)) != null)
                    return q;
                else
                    p = pl;
            } while (p != null);
            return null;
        }

由於紅黑樹也是一個二叉搜尋樹，所以查詢過程近似二分查詢法，時間複雜度是O(logn)，比連結串列查詢要快得多。有一篇介紹HashMap紅黑樹非常詳細的部落格可以參考HashMap紅黑樹解析。

三 基本操作

對於一個容器來說，核心操作無外乎增刪改查，HashMap也不例外。相對於其他操作，查詢都是首先要做的，才能進行相應的修改刪除等操作。前面一節介紹了HashMap的查詢實現，下面分析剩下的操作就比較輕鬆了。

3.1分配大小

首先來看重新分配大小的操作，這個是HashMap的基礎操作，也是最關鍵的操作之一。

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

這個步驟分為兩步，首先是擴容，針對的是存放結點的table，分以下幾種情況：

1 原table是空的，初始化為DEFAULT_INITIAL_CAPACITY；

2 原table大小是MAXIMUM_CAPACITY的，不進行改動；

3 對table不符合上述兩個條件的，擴容至二倍大小。

擴容是宣告一個指定大小的新table，再往下就是初始化新table。初始化的方式分下面成幾種情況：

1 對原先table中指定位置為null的，不作處理；

2 對原先table中指定位置只有一個元素的，則計算雜湊和下標後重新填充到新table；

3 對原table中為紅黑樹結點的，分配到新陣列中，下面會專門介紹；

4 對原table中指定位置為連結串列的，要先將連結串列拆分成兩個連結串列，拆分的依據是(e.hash & oldCap) == 0 這個判斷，為何使用這個條件呢？首先要確認，進入條件四的，都是table擴容兩倍的，原因比較顯而易見。oldCap是2的N次方，也就是第N+1位位元位為1，剩下的為0，取下標計算時，最高位為0，剩下的為1，擴容後的newCap，第N+2位為1，取下標計算時N+1以下都為1，具體可以看下圖。

這裡以HashMap預設大小16舉例， 回到擴容時(e.hash & oldCap) == 0 這個判斷條件，滿足這個條件的，第5個位元位為0，擴容以後，計算e.hash & 31 == e.hash & 15，所以在新的table中位置不變。而不滿足這個條件的，第五個位元位為1，擴容以後 e.hash & 31 == e.hash & 15 + 2^4，也就是位置增加了原先的oldCap大小。這就是根據這個判斷條件將連結串列分為hi和low兩個連結串列的依據lo連結串列位置為newTab[j] = loHead，hi連結串列位置為newTab[j + oldCap] = hiHead。不需要重新計算雜湊直接得出在新table中的下標，而且保持了原先連結串列的順序，可以說是很巧妙的設計了。

多說一句，在jdk7中，擴容以後連結串列的順序是顛倒的，而且需要計算雜湊和下標，對比而言，jdk8在這方面還是有提升的。

現在再回到條件3，原先結點是紅黑樹的情況，看看如何實現。

        /**
         * Splits nodes in a tree bin into lower and upper tree bins,
         * or untreeifies if now too small. Called only from resize;
         * see above discussion about split bits and indices.
         *
         * @param map the map
         * @param tab the table for recording bin heads
         * @param index the index of the table being split
         * @param bit the bit of hash to split on
         */
        final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
            TreeNode<K,V> b = this;
            // Relink into lo and hi lists, preserving order
            TreeNode<K,V> loHead = null, loTail = null;
            TreeNode<K,V> hiHead = null, hiTail = null;
            int lc = 0, hc = 0;
            for (TreeNode<K,V> e = b, next; e != null; e = next) {
                next = (TreeNode<K,V>)e.next;
                e.next = null;
                if ((e.hash & bit) == 0) {
                    if ((e.prev = loTail) == null)
                        loHead = e;
                    else
                        loTail.next = e;
                    loTail = e;
                    ++lc;
                }
                else {
                    if ((e.prev = hiTail) == null)
                        hiHead = e;
                    else
                        hiTail.next = e;
                    hiTail = e;
                    ++hc;
                }
            }

            if (loHead != null) {
                if (lc <= UNTREEIFY_THRESHOLD)
                    tab[index] = loHead.untreeify(map);
                else {
                    tab[index] = loHead;
                    if (hiHead != null) // (else is already treeified)
                        loHead.treeify(tab);
                }
            }
            if (hiHead != null) {
                if (hc <= UNTREEIFY_THRESHOLD)
                    tab[index + bit] = hiHead.untreeify(map);
                else {
                    tab[index + bit] = hiHead;
                    if (loHead != null)
                        hiHead.treeify(tab);
                }
            }
        }

有了前面的基礎，這一部分就很容易理解了。同樣是依據(e.hash & oldCap) == 0 這個條件，將紅黑樹退化拆分為兩個連結串列，然後根據元素是否夠轉化為紅黑樹的閾值，來決定是否要將連結串列轉為紅黑樹。

3.2 插入元素

插入元素也是關鍵操作之一，也可以是替換元素，可以是當元素為空時插入，直接看程式碼。這裡有幾個條件需要注意一下，onlyIfAbsent是判斷是否需要替換原結點，evict是標識是否是新建Map的狀態，put方法的返回值是原Value值，而不是現在要插入的Value值。

 /**
     * Associates the specified value with the specified key in this map.
     * If the map previously contained a mapping for the key, the old
     * value is replaced.
     *
     * @param key key with which the specified value is to be associated
     * @param value value to be associated with the specified key
     * @return the previous value associated with <tt>key</tt>, or
     *         <tt>null</tt> if there was no mapping for <tt>key</tt>.
     *         (A <tt>null</tt> return can also indicate that the map
     *         previously associated <tt>null</tt> with <tt>key</tt>.)
     */
    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

    /**
     * Implements Map.put and related methods.
     *
     * @param hash hash for key
     * @param key the key
     * @param value the value to put
     * @param onlyIfAbsent if true, don't change existing value
     * @param evict if false, the table is in creation mode.
     * @return previous value, or null if none
     */
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            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);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    // 插入Node的key和連結串列中元素的key相同
                    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;
    }

程式碼中有需要解釋的地方， if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))，p是table[index]的元素，這句話是比較要插入Node的Key和原Node的Key，為何需要兩種判斷條件呢？因為HashMap支援null值，null不能用equals比較，所以要先判斷Key為null的情況。

插入分以下幾種情況：

1 原table指定下標為空的，直接新建結點插入；

2 原結點是紅黑樹結點的，呼叫putTreeVal插入；

3 原結點是連結串列中的結點的，直接返回找到的結點，如果遍歷連結串列也沒找到，那就作為連結串列的末尾元素（連結串列超過閾值需要轉化為紅黑樹）。

3.3 刪除元素

有了前面的基礎，刪除元素就比較好分析了。刪除元素同樣返回的是該元素的Value值。

    /**
     * Removes the mapping for the specified key from this map if present.
     *
     * @param  key key whose mapping is to be removed from the map
     * @return the previous value associated with <tt>key</tt>, or
     *         <tt>null</tt> if there was no mapping for <tt>key</tt>.
     *         (A <tt>null</tt> return can also indicate that the map
     *         previously associated <tt>null</tt> with <tt>key</tt>.)
     */
    public V remove(Object key) {
        Node<K,V> e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }

    /**
     * Implements Map.remove and related methods.
     *
     * @param hash hash for key
     * @param key the key
     * @param value the value to match if matchValue, else ignored
     * @param matchValue if true only remove if value is equal
     * @param movable if false do not move other nodes while removing
     * @return the node, or null if none
     */
    final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
        Node<K,V>[] tab; Node<K,V> p; int n, index;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (p = tab[index = (n - 1) & hash]) != null) {
            Node<K,V> node = null, e; K k; V v;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                node = p;
            else if ((e = p.next) != null) {
                if (p instanceof TreeNode)
                    node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
                else {
                    do {
                        if (e.hash == hash &&
                            ((k = e.key) == key ||
                             (key != null && key.equals(k)))) {
                            node = e;
                            break;
                        }
                        p = e;
                    } while ((e = e.next) != null);
                }
            }
            if (node != null && (!matchValue || (v = node.value) == value ||
                                 (value != null && value.equals(v)))) {
                if (node instanceof TreeNode)
                    ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
                else if (node == p)
                    tab[index] = node.next;
                else
                    p.next = node.next;
                ++modCount;
                --size;
                afterNodeRemoval(node);
                return node;
            }
        }
        return null;
    }

也是分了幾種情況：

1 沒找到，返回null；

2 元素就是table下標元素的，該下標置為空；

3 連結串列元素的，遍歷查詢刪除；

4 在紅黑樹中的，遍歷查詢刪除。

3.4 其他方法

介紹了前面HashMap的幾個關鍵方法以後，剩下的要麼是前面方法的演變，要麼是比較顯而易見的。

按Key查詢元素，實際上和查詢結點是一樣的。

    /**
     * Returns <tt>true</tt> if this map contains a mapping for the
     * specified key.
     *
     * @param   key   The key whose presence in this map is to be tested
     * @return <tt>true</tt> if this map contains a mapping for the specified
     * key.
     */
    public boolean containsKey(Object key) {
        return getNode(hash(key), key) != null;
    }

按Value查詢元素，這個方法比較簡單粗暴，就是逐個遍歷。

    /**
     * Returns <tt>true</tt> if this map maps one or more keys to the
     * specified value.
     *
     * @param value value whose presence in this map is to be tested
     * @return <tt>true</tt> if this map maps one or more keys to the
     *         specified value
     */
    public boolean containsValue(Object value) {
        Node<K,V>[] tab; V v;
        if ((tab = table) != null && size > 0) {
            for (int i = 0; i < tab.length; ++i) {
                for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                    if ((v = e.value) == value ||
                        (value != null && value.equals(v)))
                        return true;
                }
            }
        }
        return false;
    }

清空HashMap，就是將table各個結點置為空。

    /**
     * Removes all of the mappings from this map.
     * The map will be empty after this call returns.
     */
    public void clear() {
        Node<K,V>[] tab;
        modCount++;
        if ((tab = table) != null && size > 0) {
            size = 0;
            for (int i = 0; i < tab.length; ++i)
                tab[i] = null;
        }
    }

四 小結

行文至此，HashMap基本介紹完了，簡單做個小結。HashMap是一種增刪改查操作近似於常數時間的容器，JDK1.8以後引入紅黑樹，較之前版本效率又有了較大的提升。但是需要注意的是，HashMap不是一個執行緒安全的容器，在多執行緒的環境下可能會出異常，如需要使用同步容器，請參見ConcurrentHashMap的使用。