java.util.HashMap和java.util.HashTable (JDK1.8)

一、java.util.HashMap

1.1 java.util.HashMap 綜述

java.util.HashMap繼承結構如下圖

HashMap是非線程安全的，key和value都支持null

HashMap的節點是鏈表，節點的equals比較的是節點的key和value內容是否相等。

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

1.2 HashMap屬性

HashMap中的成員變量如下：

    transient Node<K,V>[] table;
    transient Set<Map.Entry<K,V>> entrySet;
    transient int size;
    transient int modCount;
    int threshold;
    final float loadFactor;

HashMap就是Node<K, V>數組，同時也是Map.Entry<K, V>集合。 transient修飾表明這些變量是不需要被序列化的。

size是指當前HashMap中有多少個node；

threshold表示下一次resize HashMap的值，換言之當size達到這個值的時候就需要擴容了，需要將現有的元素重新散列到擴容的空間；

loadFactor加載因子，因為HashMap並不會等空間全部使用完在擴容，通常會預留一部分。該值默認為0.75，threshold = loadFactor * capacity （此處有個前提就是loadFactor * capacity < MAXIMUM_CAPACITY ，也即小於 1 << 30）

modCount表示HashMap發生結構性修改的次數。

1.3 HashMap方法

先來看下計算hash的函數 

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

這個hash算法實現的是：獲取key的hashCode()，然后高16bit不變，低16bit和高16bit異或結果作為低16bit。

在put和get方法時計算下標采用：

(n - 1) & hash

據代碼注釋解釋，這種計算下標方式是綜合考慮效率、作用和質量的結果。通常hash table的計算下標方式為模%，但是模%運算很容易發生碰撞，為什么這么說呢？不妨思考一下，在n - 1為15(0x1111)時，其實散列真正生效的只是低4bit的有效位，當然容易碰撞了。因此，設計者想了一個顧全大局的方法(綜合考慮了速度、作用、質量)，就是把高16bit和低16bit異或了一下。設計者還解釋到因為現在大多數的hashCode的分布已經很不錯了，就算是發生了碰撞也用O(logn)的tree去做了。僅僅異或一下，既減少了系統的開銷，也不會造成的因為高位沒有參與下標的計算(table長度比較小時)，從而引起的碰撞。

整個過程圖示如下：

在Java 8中使用了鏈表和紅黑樹來解決hash碰撞問題。鏈表法get一個key的時間復雜度是O(1) + O(n)，紅黑樹get一個key的時間復雜度為O(1) + O(logn)。從二者時間復雜度也能看出如果只使用鏈表解決hash碰撞，當碰撞非常嚴重的時候，效率並不理想，因此設定了一個鏈表的長度閾值，當長度超過該閾值（默認為8）則將鏈表轉換為紅黑樹。

再來看下put方法，put方法的核心是putVal方法，代碼如下

    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)
            // table還未創建，則新建之
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            // Hash 位置無數據，則直接插入
            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))))
                // hash 位置上已經存在該key，則后續判斷是否需要修改value
                e = p;
            else if (p instanceof TreeNode)
                // 紅黑樹節點，則將待插入節點插入到紅黑樹
                // 如果插入過程中發現key已經存在於紅黑樹中，則后續判斷是否需要修改value
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                // 鏈表，則插入鏈表末尾
                // 遍歷鏈表過程中如果發現key已經存在，則后續判斷是否需要修改value
                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
                            // 鏈表長度超過一定長度（默認為8）則將鏈表轉換為紅黑樹
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    // 發現key已經存在於鏈表中了
                    p = e;
                }
            }
            // table中已經存在該key了，根據onlyIfAbsent判斷是否需要修改value
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount; 
        // 判斷是否需要resize
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

上面代碼為JDK 1.8 HashMap put方法的核心部分。當調用putVal方法的時候，先按照hash算法(n - 1) & hash去table中取數據，如果取出來的是null，則新建一個newNode(hash, key, value, null)存入到下標為(n - 1) & hash的位置。

如果取出來的不是null，則說明table中以(n - 1) & hash為下標的位置上已經有數據了，這個時候有兩種情況：有可能是該key已經存在於table中了，或者發生了hash沖突。

如果確實key已經存在於table中了p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))），那么則查看onlyIfAbsent參數，如果為true則不修改該key的value，否則就更新value。

如果發生了hash沖突，此時有兩種解決方法，一種是紅黑樹，一種是鏈表。

如果是鏈表，也很好解決，循環遍歷鏈表，如果找到了某個節點的key等於待存入的key，則根據onlyIfAbsent決定是否需要更新value；找不到則新建一個節點存入到鏈表的結尾。當然這個鏈表不能無限制的擴展的，程序中設置鏈表最長為REEIFY_THRESHOLD - 1，也即為7。長度超過7則需要將鏈表構建為一顆紅黑樹。

如果不是鏈表，則需要在紅黑樹中處理，紅黑樹中同樣需要先查看key是否存在，存在則根據onlyIfAbsent決定是否更新value，不存在則new一個放入到紅黑樹中。

整個putVal方法流程圖如下圖所示。

每次調用putVal方法，如果key不存在於table中則會增加modCount，table修改次數加1。

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)
                // 通常情況下threshold成倍擴展
                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;
        // 如果不是初始化的resize，就需要重新hash了。
        if (oldTab != null) {
            // 根據oldCap遍歷整個table
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)
                        // 如果是單獨的一個節點，則重新hash到新table中
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        // 如果是紅黑樹則分裂紅黑樹
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order 保持原來的順序，否則多線程同時resize會出現jdk1.7中的死鏈問題
                        // 對鏈表節點進行重新Hash，具體Hash算法下面詳解
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            // oldCap就是新增的高位，相與 == 0則節點還應放在原下標
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else { // 相與 != 0 則節點應該放在 原下標+oldCap
                                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; // 應該放在 原下標+oldCap 位置的節點組成的鏈表
                        }
                    }
                }
            }
        }
        return newTab;
    }

當table的size超過threshold = capacity * loadFactor時，需要對HashMap進行resize操作。capacity表示table的總容量，size表示已經存入了多少node。threshold為閾值，超過該閾值則需要進行resize操作。

resize的時候，通常情況為capacity << 1， threshold << 1，也即擴展為之前的兩倍（超過MAXIMUM_CAPACITY情況另當別論）。

無論是鏈表還是紅黑樹，其中節點在resize過后都需要重新重新hash，但是Java8中重新Hash設計的非常巧妙。舉例說明，假設table從16擴展為32，具體變化為：

 

元素在重新計算hash之后，因為n變為2倍(capacity << 1)，那么n-1的mask范圍在高位多1bit(紅色)，因此新的index就會發生這樣的變化：

因此，我們在擴充HashMap的時候，不需要重新計算hash，只需要看看原來的hash值新增的那個bit是1還是0就好了，是0的話索引沒變，是1的話索引變成“原索引+oldCap”。可以看看下圖為16擴充為32的resize示意圖： 

 

這個設計確實非常的巧妙，既省去了重新計算hash值的時間，而且同時，由於新增的1bit是0還是1可以認為是隨機的，因此resize的過程，均勻的把之前的沖突的節點分散到新的table中。牛逼！

 兩個主要的函數理解之后，其它方法就不是很困難了。再來看下get方法，源碼如下：

    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))))
                // 判斷找到的第一個節點，如果key相等（相等是為了處理key為null的情況）或equal則直接返回第一個
                return first;
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)
                    // 如果是紅黑樹則去紅黑樹中查找該key
                    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;
    }

根據上面的描述，get方法還是很好理解的。在查找的時候，除了比較hash以外，還會比較key的內容(k = e.key) == key || (key != null && key.equals(k)))。

    public V remove(Object key) {
        Node<K,V> e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }

    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;
        // 先get到對應key的節點，這部分代碼跟get方法一樣
        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)
                    // 第一個節點就是待刪除節點，直接將next節點存放到index位置
                    tab[index] = node.next;
                else
                    // 鏈表，p為待刪除節點的前一個節點
                    p.next = node.next;
                ++modCount;
                --size;
                afterNodeRemoval(node);
                return node;
            }
        }
        return null;
    }

參考：

https://tech.meituan.com/java-hashmap.html

https://yikun.github.io/2015/04/01/Java-HashMap%E5%B7%A5%E4%BD%9C%E5%8E%9F%E7%90%86%E5%8F%8A%E5%AE%9E%E7%8E%B0/

 

二、java.util.Hashtable

2.1 java.util.Hashtable綜述

繼承結構如下圖：

Hashtable是線程安全的，key和value都不支持null。

2.2 Java.util.Hashtable屬性

Hashtable屬性如下，跟HashMap一樣，也是一個數組。count表示當前table中有多少個Entry，threshold、loadFactor和modCount意義同HashMap。Hashtable的初始化capacity為11，loadFactor默認為0.75f。

    private transient Entry<?,?>[] table;
    private transient int count;
    private int threshold;
    private float loadFactor;
    private transient int modCount = 0;

2.3 Java.util.Hashtable方法

先來看下get方法

    public synchronized V get(Object key) {
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                return (V)e.value;
            }
        }
        return null;
    }

get方法是synchronized方法，多線程執行的時候給整個hashtable對象加鎖，這樣一來效率肯定會打折扣，但是線程是安全的。

在hashtable中，index = (hash & 0x7FFFFFFF) % tab.length，將key.hashCode()除去符號位模上tab.length。目前hashtable仍然只使用了鏈表去解決hash碰撞問題，因此，如果tab[index]沒找到，則遍歷鏈表繼續查找即可，算法復雜讀O(n)。

在查找的時候除了比較hash值以外還會要求e.key.equals(key)對內容進行比較，因為key不允許為null，因此e.key也能保證不為null。

    private void addEntry(int hash, K key, V value, int index) {
        modCount++;

        Entry<?,?> tab[] = table;
        if (count >= threshold) {
            // 超過閾值，需要擴容，重新hash
            // Rehash the table if the threshold is exceeded
            rehash();

            tab = table;
            hash = key.hashCode();
            index = (hash & 0x7FFFFFFF) % tab.length;
        }

        // Creates the new entry.
        @SuppressWarnings("unchecked")
        // 保存下當前鏈表頭部節點
        Entry<K,V> e = (Entry<K,V>) tab[index];
        // 插入到鏈表頭部
        tab[index] = new Entry<>(hash, key, value, e);
        count++;
    }

    public synchronized V put(K key, V value) {
        // Make sure the value is not null
        if (value == null) {
            throw new NullPointerException();
        }

        // Makes sure the key is not already in the hashtable.
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        Entry<K,V> entry = (Entry<K,V>)tab[index];
        for(; entry != null ; entry = entry.next) {
            if ((entry.hash == hash) && entry.key.equals(key)) {
                // 如果key已經存在於hashtable，則直接替換舊的value
                V old = entry.value;
                entry.value = value;
                return old;
            }
        }
        // 新建Entry，放在index位置上鏈表的頭部    
        addEntry(hash, key, value, index);
        return null;
    }

上面為put方法，put方法還是比較簡單的，已經存在就更新value值，沖突了就添加到鏈表頭部。

    public synchronized V remove(Object key) {
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        // 定位下標
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        Entry<K,V> e = (Entry<K,V>)tab[index];
        // 遍歷鏈表，prev保存前一個節點
        for(Entry<K,V> prev = null ; e != null ; prev = e, e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                modCount++;
                // 鏈表刪除節點
                if (prev != null) {
                    prev.next = e.next;
                } else {
                    tab[index] = e.next;
                }
                count--;
                V oldValue = e.value;
                e.value = null;
                return oldValue;
            }
        }
        return null;
    }

remove節點也比較簡單。

    protected void rehash() {
        int oldCapacity = table.length;
        Entry<?,?>[] oldMap = table;

        // overflow-conscious code
        // 擴容為oldCapacity兩倍+1
        int newCapacity = (oldCapacity << 1) + 1;
        if (newCapacity - MAX_ARRAY_SIZE > 0) {
            if (oldCapacity == MAX_ARRAY_SIZE)
                // Keep running with MAX_ARRAY_SIZE buckets
                return;
            newCapacity = MAX_ARRAY_SIZE;
        }
        Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];

        modCount++;
        threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
        table = newMap;
        // 擴容后需要對原有數據進行重新hash分配位置
        for (int i = oldCapacity ; i-- > 0 ;) {
            for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
                Entry<K,V> e = old;
                // 遍歷鏈表
                old = old.next;
                // 重新確定位置
                int index = (e.hash & 0x7FFFFFFF) % newCapacity;
                // 新到來的節點插到鏈表開頭位置
                e.next = (Entry<K,V>)newMap[index];
                newMap[index] = e;
            }
        }
    }

rehash擴容方法也還是比較簡單，如果遇到鏈表遍歷一下重新hash每個鏈表上的節點即可。

    public synchronized V putIfAbsent(K key, V value) {
        Objects.requireNonNull(value);

        // Makes sure the key is not already in the hashtable.
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        Entry<K,V> entry = (Entry<K,V>)tab[index];
        // 先查找是否存在
        for (; entry != null; entry = entry.next) {
            if ((entry.hash == hash) && entry.key.equals(key)) {
                V old = entry.value;
                if (old == null) {
                    entry.value = value;
                }
                return old;
            }
        }
        // 不存在，則創建新節點插到鏈表開頭
        addEntry(hash, key, value, index);
        return null;
    }

在putIfAbsent方法中需要先查找，找不到key或者key存在但是value為null，則插入。但是put方法中能確保插入的節點value都不為null，所以value為null的場景應該是不存在的。