一、數(shù)組和鏈表介紹

數(shù)組和鏈表是兩種基本的數(shù)據(jù)結(jié)構(gòu)，他們在內(nèi)存存儲(chǔ)上的表現(xiàn)不一樣，所以也有各自的特點(diǎn)。
以5位同學(xué)去上課時(shí)坐座位為例，總結(jié)它們的特點(diǎn)和區(qū)別。

1.1、數(shù)組的特點(diǎn)

數(shù)組中5位同學(xué)連坐一起

• 在內(nèi)存中，數(shù)組是一塊連續(xù)的區(qū)域。
  也就是這5位同學(xué)必須坐在一起。
• 數(shù)組需要預(yù)留空間，在使用前要先申請占內(nèi)存的大小，可能會(huì)浪費(fèi)內(nèi)存空間。
  比如上課時(shí)，為了保證五位同學(xué)可以坐在一起，必須提前訂好五個(gè)連續(xù)的位置。這樣的好處就是能保證五個(gè)人可以在一起。但是這樣的缺點(diǎn)是，如果來的人不夠五個(gè)，那么剩下的位置就浪費(fèi)了。如果臨時(shí)又多來了個(gè)人，那么五個(gè)就不夠用了，這時(shí)可能需要將第六個(gè)位置上的人挪走，或者是他們六個(gè)人重新去找一個(gè)六連坐的位置，效率都很低。如果沒有找到符合要求的座位，那么就沒法坐了。
• 插入數(shù)據(jù)和刪除數(shù)據(jù)效率低，插入數(shù)據(jù)時(shí)，這個(gè)位置后面的數(shù)據(jù)在內(nèi)存中都要向后移。刪除數(shù)據(jù)時(shí)，這個(gè)數(shù)據(jù)后面的數(shù)據(jù)都要往前移動(dòng)。 比如原來去了四個(gè)人，然后后來又去了一個(gè)人要坐在第三個(gè)位置上，那么第三個(gè)到第四個(gè)都要往后移動(dòng)一個(gè)位子，將第三個(gè)位置留給新來的人。 當(dāng)這個(gè)人走了的時(shí)候，因?yàn)樗麄円B在一起的，所以他后面幾個(gè)人要往前移動(dòng)一個(gè)位置，把這個(gè)空位補(bǔ)上。
• 隨機(jī)讀取效率很高。因?yàn)閿?shù)組是連續(xù)的，知道每一個(gè)數(shù)據(jù)的內(nèi)存地址，可以直接找到給地址的數(shù)據(jù)。
• 不利于擴(kuò)展，數(shù)組定義的空間不夠時(shí)要重新定義數(shù)組。

1.2、鏈表的特點(diǎn)

鏈表中5位同學(xué)

• 在內(nèi)存中可以存在任何地方，不要求連續(xù)。 在教室里五個(gè)人可以隨便坐。
• 每一個(gè)數(shù)據(jù)都保存了下一個(gè)數(shù)據(jù)的內(nèi)存地址，通過這個(gè)地址找到下一個(gè)數(shù)據(jù)。第一個(gè)人知道第二個(gè)人的座位號(hào)，第二個(gè)人知道第三個(gè)人的座位號(hào)...
• 增加數(shù)據(jù)和刪除數(shù)據(jù)很容易。 再來個(gè)人可以隨便坐，比如來了個(gè)人要坐到第三個(gè)位置，那他只需要把自己的位置告訴第二個(gè)人，然后問第二個(gè)人拿到原來第三個(gè)人的位置就行了。其他人都不用動(dòng)。
• 查找數(shù)據(jù)時(shí)效率低，因?yàn)椴痪哂须S機(jī)訪問性，所以訪問某個(gè)位置的數(shù)據(jù)都要從第一個(gè)數(shù)據(jù)開始訪問，然后根據(jù)第一個(gè)數(shù)據(jù)保存的下一個(gè)數(shù)據(jù)的地址找到第二個(gè)數(shù)據(jù)，以此類推。要找到第三個(gè)人，必須從第一個(gè)人開始問起。
• 不指定大小，擴(kuò)展方便。鏈表大小不用定義，數(shù)據(jù)隨意增刪。

1.3、各自的優(yōu)缺點(diǎn)

數(shù)組的優(yōu)點(diǎn)

• 隨機(jī)訪問性強(qiáng)
• 查找速度快

數(shù)組的缺點(diǎn)

• 插入和刪除效率低
• 可能浪費(fèi)內(nèi)存
• 內(nèi)存空間要求高，必須有足夠的連續(xù)內(nèi)存空間
• 數(shù)組大小固定，不能動(dòng)態(tài)拓展

鏈表的優(yōu)點(diǎn)

• 插入刪除速度快
• 內(nèi)存利用率高，不會(huì)浪費(fèi)內(nèi)存
• 大小沒有固定，拓展很靈活

鏈表的缺點(diǎn)

• 不能隨機(jī)查找，必須從第一個(gè)開始遍歷，查找效率低

它們在讀取、插入和刪除時(shí)時(shí)間復(fù)雜度對(duì)比

二、HashMap是一種哈希表，綜合了數(shù)組和鏈表兩者的特性

講完數(shù)組和鏈表，我們再來講講HashMap。
偉大的程序員們一直在想：我們能不能綜合數(shù)組和鏈表兩者的特性，做出一種讀取容易，插入、刪除也容易的數(shù)據(jù)結(jié)構(gòu)？答案是肯定的，這就是我們要提起的哈希表（Hash table）。
哈希表有多種不同的實(shí)現(xiàn)方法，最常用的一種方法是拉鏈法，也叫“鏈表的數(shù)組” ，如圖：

鏈表的數(shù)組實(shí)現(xiàn)的哈希表

前面5位同學(xué)的存儲(chǔ)方式（猜測）

哈希表是由數(shù)組+鏈表組成的，一個(gè)長度為16的數(shù)組中，每個(gè)元素存儲(chǔ)的是一個(gè)鏈表的頭結(jié)點(diǎn)。這些元素一般情況是通過hash(key)%len的規(guī)則存儲(chǔ)到數(shù)組中，也就是元素的key的哈希值對(duì)數(shù)組長度取模得到。比如上述哈希表中，1%16=1,2%16=2,3%16=3,4%16=4,5%16=5,17%16=1,33%16=1。所以1、17以及33都存儲(chǔ)在數(shù)組下標(biāo)為1的位置。

三、HashMap源碼解析

3.1、HashMap類圖結(jié)構(gòu)

HashMap類圖結(jié)構(gòu)（網(wǎng)上的圖）

3.2、HashMap數(shù)據(jù)結(jié)構(gòu)和重要概念

鏈表的數(shù)組實(shí)現(xiàn)的哈希表

HashMap重要概念，其中實(shí)體在JDK1.8之前為Entry，JDK1.8為Node

在Java編程語言中，最基本的結(jié)構(gòu)就是兩種，一個(gè)是數(shù)組，另外一個(gè)是指針（引用）。所有的數(shù)據(jù)結(jié)構(gòu)都可以用這兩個(gè)基本結(jié)構(gòu)來構(gòu)造的，HashMap也不例外。HashMap實(shí)際上是一個(gè)“鏈表散列”的數(shù)據(jù)結(jié)構(gòu)，即數(shù)組和鏈表的結(jié)合體。

從上圖中我們知道HashMap底層就是一個(gè)數(shù)組結(jié)構(gòu)，數(shù)組中的每一項(xiàng)又是一個(gè)鏈表。當(dāng)新建一個(gè)HashMap的時(shí)候，就會(huì)初始化一個(gè)數(shù)組。

見HashMap的源碼（JDK1.8）：

   transient Node<K,V>[] table;

   // Node是單向鏈表，它實(shí)現(xiàn)了Map.Entry接口
   static class Node<K,V> implements Map.Entry<K,V> {
       final int hash;
       final K key;
       V value;
       Node<K,V> next;

       // 構(gòu)造函數(shù)：Hash值 鍵 值 下一個(gè)節(jié)點(diǎn)
       Node(int hash, K key, V value, Node<K,V> next) {
           this.hash = hash;
           this.key = key;
           this.value = value;
           this.next = next;
       }

       public final K getKey()        { return key; }
       public final V getValue()      { return value; }
       public final String toString() { return key + "=" + value; }

       public final int hashCode() {
           return Objects.hashCode(key) ^ Objects.hashCode(value);
       }

       public final V setValue(V newValue) {
           V oldValue = value;
           value = newValue;
           return oldValue;
       }

       // 判斷兩個(gè)node是否相等，若key和value都相等，返回true
       public final boolean equals(Object o) {
           if (o == this)
               return true;
           if (o instanceof Map.Entry) {
               Map.Entry<?,?> e = (Map.Entry<?,?>)o;
               if (Objects.equals(key, e.getKey()) &&
                   Objects.equals(value, e.getValue()))
                   return true;
           }
           return false;
       }
   }

可以看出，HashMap里面實(shí)現(xiàn)一個(gè)靜態(tài)內(nèi)部類Node（JDK1.8之前的應(yīng)該是Entry），其重要的屬性有key、value、next，從屬性key、value我們就能很明顯的看出來Node就是HashMap鍵值對(duì)實(shí)現(xiàn)的一個(gè)基礎(chǔ)bean，我們上面說到HashMap的基礎(chǔ)就是一個(gè)線性數(shù)組，這個(gè)數(shù)組就是Node<K,V>[] table，Map里面的內(nèi)容都保存在Node<K,V>[] table里面。

3.3、HashMap的存取實(shí)現(xiàn)

存儲(chǔ)

    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

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

從上面的源代碼中可以看出：當(dāng)我們往HashMap中put元素的時(shí)候，先根據(jù)key的hashCode重新計(jì)算hash值，根據(jù)hash值得到這個(gè)元素在數(shù)組中的位置（即下標(biāo)）， 如果數(shù)組該位置上已經(jīng)存放有其他元素了，那么在這個(gè)位置上的元素將以鏈表的形式存放，新加入的放在鏈頭，最先加入的放在鏈尾。如果數(shù)組該位置上沒有元素，就直接將該元素放到此數(shù)組中的該位置上。
這里有一個(gè)特殊的地方。在JDK1.6中，HashMap采用位桶+鏈表實(shí)現(xiàn)，即使用鏈表處理沖突，同一hash值的鏈表都存儲(chǔ)在一個(gè)鏈表里。但是當(dāng)位于一個(gè)桶中的元素較多，即hash值相等的元素較多時(shí)，通過key值依次查找的效率較低。而JDK1.8中，HashMap采用位桶+鏈表+紅黑樹實(shí)現(xiàn)，當(dāng)鏈表長度超過閾值（8）時(shí)，將鏈表轉(zhuǎn)換為紅黑樹，這樣大大減少了查找時(shí)間。
如下源碼：

static final int TREEIFY_THRESHOLD = 8;

if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
    treeifyBin(tab, hash);

紅黑樹源碼：

    final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode<K,V> hd = null, tl = null;
            do {
                TreeNode<K,V> p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                hd.treeify(tab);
        }
    }

    ...
    // 紅黑樹
    static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        TreeNode<K,V> parent;  // 父節(jié)點(diǎn)
        TreeNode<K,V> left;  // 左子樹
        TreeNode<K,V> right;  // 右子樹
        TreeNode<K,V> prev;    // needed to unlink next upon deletion
        boolean red;  // 顏色屬性
        TreeNode(int hash, K key, V val, Node<K,V> next) {
            super(hash, key, val, next);
        }

        // 返回當(dāng)前節(jié)點(diǎn)的根節(jié)點(diǎn)
        final TreeNode<K,V> root() {
            for (TreeNode<K,V> r = this, p;;) {
                if ((p = r.parent) == null)
                    return r;
                r = p;
            }
        }
        ...
    }

讀取

    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; 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 && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                // 如果第一個(gè)節(jié)點(diǎn)是TreeNode,說明采用的是數(shù)組+紅黑樹結(jié)構(gòu)處理沖突
                // 遍歷紅黑樹，得到節(jié)點(diǎn)值
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                // 鏈表結(jié)構(gòu)處理
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

有了上面存儲(chǔ)時(shí)的hash算法作為基礎(chǔ)，理解起來這段代碼就很容易了。從上面的源代碼中可以看出：
從HashMap中g(shù)et元素時(shí)，首先計(jì)算key的hashCode，找到數(shù)組中對(duì)應(yīng)位置的某一元素，然后通過key的equals方法在對(duì)應(yīng)位置的鏈表中找到需要的元素。
如果第一個(gè)節(jié)點(diǎn)是TreeNode,說明采用的是數(shù)組+紅黑樹結(jié)構(gòu)處理沖突，遍歷紅黑樹，得到節(jié)點(diǎn)值。

歸納
簡單地說，HashMap 在底層將 key-value 當(dāng)成一個(gè)整體進(jìn)行處理，這個(gè)整體就是一個(gè) Node 對(duì)象。HashMap 底層采用一個(gè) Node<K,V>[] 數(shù)組來保存所有的 key-value 對(duì)，當(dāng)需要存儲(chǔ)一個(gè) Node 對(duì)象時(shí)，會(huì)根據(jù)hash算法來決定其在數(shù)組中的存儲(chǔ)位置，在根據(jù)equals方法決定其在該數(shù)組位置上的鏈表中的存儲(chǔ)位置；當(dāng)需要取出一個(gè)Entry時(shí)，也會(huì)根據(jù)hash算法找到其在數(shù)組中的存儲(chǔ)位置，再根據(jù)equals方法從該位置上的鏈表中取出該Node。

3.4、HashMap的resize（rehash）

當(dāng)HashMap中的元素越來越多的時(shí)候，hash沖突的幾率也就越來越高，因?yàn)閿?shù)組的長度是固定的。所以為了提高查詢的效率，就要對(duì)HashMap的數(shù)組進(jìn)行擴(kuò)容，數(shù)組擴(kuò)容這個(gè)操作也會(huì)出現(xiàn)在ArrayList中，這是一個(gè)常用的操作，而在HashMap數(shù)組擴(kuò)容之后，最消耗性能的點(diǎn)就出現(xiàn)了：原數(shù)組中的數(shù)據(jù)必須重新計(jì)算其在新數(shù)組中的位置，并放進(jìn)去，這就是resize。

那么HashMap什么時(shí)候進(jìn)行擴(kuò)容呢？當(dāng)HashMap中的元素個(gè)數(shù)超過數(shù)組大小loadFactor時(shí)，就會(huì)進(jìn)行數(shù)組擴(kuò)容，loadFactor的默認(rèn)值為0.75，這是一個(gè)折中的取值。也就是說，默認(rèn)情況下，數(shù)組大小為16，那么當(dāng)HashMap中元素個(gè)數(shù)超過16*0.75=12的時(shí)候，就把數(shù)組的大小擴(kuò)展為 2*16=32，即擴(kuò)大一倍，然后重新計(jì)算每個(gè)元素在數(shù)組中的位置，而這是一個(gè)非常消耗性能的操作，所以如果我們已經(jīng)預(yù)知HashMap中元素的個(gè)數(shù)，那么預(yù)設(shè)元素的個(gè)數(shù)能夠有效的提高HashMap的性能。

這里有個(gè)疑問：為什么默認(rèn)初始化桶數(shù)組大小為16，為什么加載因子的大小為0.75，這兩個(gè)值的選取有什么特點(diǎn)。
網(wǎng)上有位博主的回答如下，我也是比較認(rèn)可這種說法。

通過看上面的代碼我們可以知道這兩個(gè)值主要影響的threshold的大小，這個(gè)值的數(shù)值是當(dāng)前桶數(shù)組需不需要擴(kuò)容的邊界大小。

我們都知道桶數(shù)組如果擴(kuò)容，會(huì)申請內(nèi)存空間，然后把原桶中的元素復(fù)制進(jìn)新的桶數(shù)組中，這是一個(gè)比較耗時(shí)的過程。既然這樣，那為何不把這兩個(gè)值都設(shè)置大一些呢，threshold是兩個(gè)數(shù)的乘積，設(shè)置大一些就不那么容易會(huì)進(jìn)行擴(kuò)容了啊。

原因是這樣的，如果桶初始化桶數(shù)組設(shè)置太大，就會(huì)浪費(fèi)內(nèi)存空間，16是一個(gè)折中的大小，既不會(huì)像1，2，3那樣放幾個(gè)元素就擴(kuò)容，也不會(huì)像幾千幾萬那樣可以只會(huì)利用一點(diǎn)點(diǎn)空間從而造成大量的浪費(fèi)。

加載因子設(shè)置為0.75而不是1，是因?yàn)樵O(shè)置過大，桶中鍵值對(duì)碰撞的幾率就會(huì)越大，同一個(gè)桶位置可能會(huì)存放好幾個(gè)value值，這樣就會(huì)增加搜索的時(shí)間，性能下降，設(shè)置過小也不合適，如果是0.1，那么10個(gè)桶，threshold為1，你放兩個(gè)鍵值對(duì)就要擴(kuò)容，太浪費(fèi)空間了。

這里的0.75，據(jù)說是Oracle的開發(fā)人員經(jīng)過泊松分布得到的一個(gè)值。

怎么設(shè)置？
HashMap總共給出了4中構(gòu)造方法。
1）HashMap（） 不帶參數(shù)，默認(rèn)初始化大小為16，加載因子為0.75；
2）HashMap（int initialCapacity） 指定初始化大?。?br> 3）HashMap（int initialCapacity ,float loadFactor）指定初始化大小和加載因子大?。?br> 4）HashMap(Map<? extends K,? extends V> m) 用現(xiàn)有的一個(gè)map來構(gòu)造HashMap。

我在這里還有一個(gè)疑問：這里的16在實(shí)際使用HashMap的時(shí)候，如何根據(jù)業(yè)務(wù)去進(jìn)行預(yù)設(shè)呢？