概念

HashMap是Java Collections Framework中Map集合的一種實現(xiàn)。HashMap提供了一種簡單實用的數(shù)據(jù)存儲和讀取方式。Map接口不同于List接口，屬于集合框架的另一條支線，Map提供了鍵值對K-V數(shù)據(jù)存儲模型，底層則是通過Hash表存儲。

本文分析基于JDK1.8。

類結(jié)構(gòu)

HashMap實現(xiàn)了Map接口，Map接口設(shè)置一系列操作Map集合的方法，如：put、get、remove...等方法，而HashMap也針對此有其自身對應(yīng)的實現(xiàn)。

HashMap繼承AbstractMap類。AbstractMap類對于Map接口做了基礎(chǔ)的實現(xiàn)，實現(xiàn)了containsKey、containsValue...等方法。

類成員

構(gòu)造函數(shù)

HashMap提供四種構(gòu)造函數(shù)。最為基礎(chǔ)是如下這種：

HashMap(int initialCapacity, float loadFactor)

   public HashMap(int initialCapacity, float loadFactor) {
   
        ...        
  
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }

HashMap(int initialCapacity, float loadFactor)是最基礎(chǔ)的構(gòu)造函數(shù)。該構(gòu)造函數(shù)提供兩個參數(shù)initialCapacity(初始大小)、loadFactor(加載因子)。

• initialCapacity默認值是16 (1 << 4),最大值是 1073 741 824(1 << 30)，且大小必須是小于最大值的2的冪次方；
• loadFactor默認值是0.75，作用是擴容時使用；

初始化的過程中將傳入的參數(shù)loadFactor賦值給this.loadFactor，然后調(diào)用tableSizeFor(initialCapacity)方法將處理的結(jié)果值賦值給this.threshold;

threshold是HashMap判斷size是否需要擴容的閾值。這里調(diào)用tableSizeFor(initialCapacity)來設(shè)置threshold;

tableSizeFor有啥用？

先拋出答案：tableSizeFor方法保證函數(shù)返回值是大于等于給定參數(shù)initialCapacity最小的2的冪次方的數(shù)值。

如何實現(xiàn)？

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

可以看出該方法是一系列的二進制位操作。先說明 |=的作用：a |= b 等同于 a = a|b。逐行分析tableSizeFor方法：

• int n = cap - 1

  • 給定的cap減1，是為了避免參數(shù)cap本來就是2的冪次方，這樣一來，經(jīng)過后續(xù)的未操作的，cap將會變成2 * cap,是不符合我們預(yù)期的。

• n |= n >>> 1

  • n >>> 1，n無符號右移1位，即n二進制最高位的1右移一位；
  • n | (n >>> 1)，導(dǎo)致的結(jié)果是n二進制的高2位值為1;

  目前n的高1~2位均為1。

• n |= n >>> 2

  • n繼續(xù)無符號右移2位。
  • n | (n >>> 2)，導(dǎo)致n二進制表示高3~4位經(jīng)過運算值均為1；

  目前n的高1~4位均為1。

• n |= n >>> 4

  • n繼續(xù)無符號右移4位。
  • n | (n >>> 4)，導(dǎo)致n二進制表示高5~8位經(jīng)過運算值均為1；

  目前n的高1~8位均為1。

• n |= n >>> 8

  • n繼續(xù)無符號右移8位。
  • n | (n >>> 8)，導(dǎo)致n二進制表示高9~16位經(jīng)過運算值均為1；

  目前n的高1~16位均為1。

• n |= n >>> 16

  • n繼續(xù)無符號右移16位。
  • n | (n >>> 16)，導(dǎo)致n二進制表示高17~32位經(jīng)過運算值均為1；

  目前n的高1~32位均為1。

可以看出，無論給定cap(cap < MAXIMUM_CAPACITY )的值是多少，經(jīng)過以上運算，其值的二進制所有位都會是1。再將其加1，這時候這個值一定是2的冪次方。當然如果經(jīng)過運算值大于MAXIMUM_CAPACITY，直接選用MAXIMUM_CAPACITY。

這里可以舉個栗子，假設(shè)給定的cap的值為20。

• int n = cap - 1; —> n = 19(二進制表示：0001 0011)

• n |= n >>> 1;

    n             ->  0001 0011
    n >>> 1       ->  0000 1001
    n |= n >>> 1  ->  0001 1011

• n |= n >>> 2;

    n             ->  0001 1011
    n >>> 2       ->  0000 1101
    n |= n >>> 2  ->  0001 1111

此時n所有位均為1，后續(xù)的位操作均不再改變n的值。

...

    n + 1        ->  0010 0000 (32)

最終，tableSizeFor(20)的結(jié)果為32(2^5)。

至此tableSizeFor如何保證cap為2的冪次方已經(jīng)顯而易見了。那么問題來了，為什么cap要保持為2的冪次方？

為什么cap要保持為2的冪次方？

cap要保持為2的冪次方主要原因是HashMap中數(shù)據(jù)存儲有關(guān)。

在JDK1.8中，HashMap中key的Hash值由Hash(key)方法（后面會詳細分析）計算得來。

HashMap中存儲數(shù)據(jù)table的index是由key的Hash值決定的。在HashMap存儲數(shù)據(jù)的時候，我們期望數(shù)據(jù)能夠均勻分布，以避免哈希沖突。自然而然我們就會想到去用%取余的操作來實現(xiàn)我們這一構(gòu)想。

這里要了解到一個知識：取余(%)操作中如果除數(shù)是2的冪次方則等同于與其除數(shù)減一的與(&)操作。

這也就解釋了為啥一定要求cap要為2的冪次方。再來看看table的index的計算規(guī)則：

 index = e.hash & (newCap - 1) 
 
 等同于：
 
 index = e.hash % newCap

采用二進制位操作&，相對于%，能夠提高運算效率，這就是要求cap的值被要求為2冪次方的原因。

Node<K,V> 類

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

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

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

Node<K,V> 類是HashMap中的靜態(tài)內(nèi)部類，實現(xiàn)Map.Entry<K,V>接口。 定義了key鍵、value值、next節(jié)點，也就是說元素之間構(gòu)成了單向鏈表。

Node<K,V>[] table

Node<K,V>[] table是HashMap底層存儲的數(shù)據(jù)結(jié)構(gòu)，是一個Node數(shù)組。上面得知Node類為元素維護了一個單向鏈表。

至此，HashMap存儲的數(shù)據(jù)結(jié)構(gòu)也就很清晰了：維護了一個數(shù)組，每個數(shù)組又維護了一個單向鏈表。之所以這么設(shè)計，考慮到遇到哈希沖突的時候，同index的value值就用單向鏈表來維護。

hash(K,V) 方法

HashMap中table的index是由Key的哈希值決定的。HashMap并沒有直接使用key的hashcode()，而是經(jīng)過如下的運算：

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

而上面我們提到index的運算規(guī)則是e.hash & (newCap - 1)。由于newCap是2的冪次方，那么newCap - 1的高位應(yīng)該全部為0。如果e.hash值只用自身的hashcode的話，那么index只會和e.hash低位做&操作。這樣一來，index的值就只有低位參與運算，高位毫無存在感，從而會帶來哈希沖突的風(fēng)險。所以在計算key的哈希值的時候，用其自身hashcode值與其低16位做異或操作。這也就讓高位參與到index的計算中來了，即降低了哈希沖突的風(fēng)險又不會帶來太大的性能問題。

put(K,V) 方法

  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)
            // tab 為空,調(diào)用resize()初始化tab。
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            // key沒有被占用的情況下,將value封裝為Node并賦值
            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))))
                // 如果key相同,p賦值給e
                e = p;
            else if (p instanceof TreeNode)
                // 如果p是紅黑樹類型，調(diào)用putTreeVal方式賦值
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                // index 相同的情況下
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        // 如果p的next為空，將新的value值添加至鏈表后面
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            // 如果鏈表長度大于8，鏈表轉(zhuǎn)化為紅黑樹，執(zhí)行插入
                            treeifyBin(tab, hash);
                        break;
                    }
                    // key相同則跳出循環(huán)
                    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;
                //根據(jù)規(guī)則選擇是否覆蓋value
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            // size大于加載因子,擴容
            resize();
        afterNodeInsertion(evict);
        return null;
    }

在構(gòu)造函數(shù)中最多也只是設(shè)置了initialCapacity、loadFactor的值，并沒有初始化table，table的初始化工作是在put方法中進行的。

resize() 方法

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) {
            // table已存在
            if (oldCap >= MAXIMUM_CAPACITY) {
                // oldCap大于MAXIMUM_CAPACITY,threshold設(shè)置為int的最大值
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                //newCap設(shè)置為oldCap的2倍并小于MAXIMUM_CAPACITY，且大于默認值, 新的threshold增加為原來的2倍
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            // threshold>0, 將threshold設(shè)置為newCap,所以要用tableSizeFor方法保證threshold是2的冪次方
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            // 默認初始化，cap為16，threshold為12。
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            // newThr為0，newThr = newCap * 0.75
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
            // 新生成一個table數(shù)組
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            // oldTab 復(fù)制到 newTab
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)
                       // 鏈表只有一個節(jié)點，直接賦值
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        // e為紅黑樹的情況
                        ((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;
    }

remove(key) 方法 & remove(key, value) 方法

remove(key) 方法 和 remove(key, value) 方法都是通過調(diào)用removeNode的方法來實現(xiàn)刪除元素的。

    
     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))))
                // index 元素只有一個元素
                node = p;
            else if ((e = p.next) != null) {
                if (p instanceof TreeNode)
                    // index處是一個紅黑樹
                    node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
                else {
                    // index處是一個鏈表，遍歷鏈表返回node
                    do {
                        if (e.hash == hash &&
                            ((k = e.key) == key ||
                             (key != null && key.equals(k)))) {
                            node = e;
                            break;
                        }
                        p = e;
                    } while ((e = e.next) != null);
                }
            }
            // 分不同情形刪除節(jié)點
            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;
    }