Java經常使用數據結構之Map-HashMap

時間 2019-11-06

標籤 java 經常使用數據結構 map hashmap 欄目 Java 简体版

原文原文鏈接

Java經常使用數據結構
java

Java經常使用數據結構之Map-AbstractMap
Java經常使用數據結構之Map-HashMapnode

android經常使用數據結構
android

ArrayMap是如何提升內存的使用效率的？
SparseArray原理分析
git

做者：QiShare 連接：www.jianshu.com/p/9eea61925… 來源：簡書簡書著做權歸做者全部，任何形式的轉載都請聯繫做者得到受權並註明出處。github

前言

上篇文章中介紹了AbstractMap抽象類，本文就來分析一下HashMap類。jdk1.8對HashMap進行了大幅優化。在jdk1.8以前，HashMap的實現是數組+鏈表，即經過拉鍊法來解決Hash衝突。假設鏈表的長度爲n，則鏈表中查找元素的時間複雜度爲O(n)，若是n特別大，就會很耗時。在jdk1.8中，HashMap的實現改爲了數組+鏈表+紅黑樹，即當n超過某個閥值時，會將鏈表轉化爲紅黑樹，此時的查找元素複雜度就變成了O(logn)，效率明顯提升。數組

本文中的源碼分析是基於jdk11的，但經過比較發現，jdk11和jdk8的源碼實現並沒有多少變化。本文會帶着幾個問題去分析源碼。
安全

HashMap中默認參數有哪些？分別表明什麼意思？值分別是多少？
HashMap是何時進行buckets初始化的？
HashMap是怎麼計算Key的存放位置的？
HashMap如何擴容？
HashMap如何添加元素？
HashMap什麼時候將鏈表轉化爲紅黑樹？

源碼分析

類結構

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
複製代碼

HashMap繼承了AbstractMap模板類，那確定會實現entrySet()方法；實現了Serializable接口，所以它支持序列化；實現了Cloneable接口，能被克隆。微信

而後看看HashMap中實現的Map.Entry：數據結構

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash; // key的hash值
        final K key; // key
        V value; // value
        Node<K,V> next; // 鏈表中的下一個結點
複製代碼

Node是用來表示數組和鏈表中結點的數據結構。在數組中，不會用到next屬性，在解決衝突的鏈表中才會用到。app

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        TreeNode<K,V> parent;  // red-black tree links
        TreeNode<K,V> left; // 左子樹
        TreeNode<K,V> right; // 右子樹
        TreeNode<K,V> prev;    // needed to unlink next upon deletion
        boolean red; // 標記顏色：紅 or 黑
複製代碼

TreeNode顧名思義是用來表示紅黑樹中結點的數據結構。注意，這裏是繼承了LinkedHashMap.Entry，但往上追溯，能夠發現LinkedHashMap.Entry其實繼承的也是HashMap.Node。因此，在代碼看到Node instanceOf TreeNode時不要奇怪。

重要屬性

這裏就直接在代碼裏用註釋進行說明了：

transient Node<K,V>[] table; // Hash數組，存放bucket
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 數組默認大小爲16
static final int MAXIMUM_CAPACITY = 1 << 30; // 數組最大容量爲2的30次方
static final float DEFAULT_LOAD_FACTOR = 0.75f; // 默認負載因子爲0.75

final float loadFactor; // 存儲負載因子
int threshold; // 須要進行下次擴容的閥值，計算方法爲：容量 * 負載因子

// 當鏈表中的結點數大於8時，會轉換爲紅黑樹
static final int TREEIFY_THRESHOLD = 8; 
// 當紅黑樹中的結點數小於6時，會轉換爲鏈表，這裏不使用8是爲了不頻繁轉換
static final int UNTREEIFY_THRESHOLD = 6; 
// 當哈希表的容量小於64時，是不會進行紅黑樹轉換的，而是進行擴容；這個值不能小於 4 * TREEIFY_THRESHOLD
static final int MIN_TREEIFY_CAPACITY = 64;
複製代碼

初始化和擴容

說到初始化，第一想法確定是構造函數：

public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor; // 賦值負載因子
         // 計算一個恰好比initialCapacity大的2的次方數
        this.threshold = tableSizeFor(initialCapacity);
    }
複製代碼

能夠發現構造函數裏並無對table進行初始化。其實，初始化是發生在第一次添加key-value值的時候，而第一次添加鍵值對會觸發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) {
            // 超出最大容量，再也不擴容
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            // 擴充爲原來的2倍
            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) {
            // 這裏就是舊bucket移到新buckets中
            ......
        }
        return newTab;
    }
複製代碼

從代碼中能夠看到初始化值是在第一次擴容時發生的。哈希表的每次擴容，都是把容量擴大爲原來的2倍，這裏爲何是2倍，會在下面進行分析。

添加key-value

在看put方法以前，須要知道HashMap是如何對Key進行hashcode散列和結點位置計算的。先看hash()函數：

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

關鍵點(h = key.hashCode()) ^ (h >>> 16)。其中h >>> 16意思是把h向右移位16位，而且高位補0。而後，再和原hashcdoe進行異或操做。理解起來就是把原hashcode的高16位和低16位進行異或處理，從而下降衝突概率。

在看結點位置計算方法：

index = (n - 1) & hash // n是當前容量，hash是hash()計算出的值
複製代碼

由於table容量必須是2的冪次方，因此這裏用了n-1。用一個例子幫助理解hashcode向下標轉換的過程：

圖片來自：Java HashMap工做原理及實現

上文說過每次擴容的時候都是變成原來的2倍，爲何呢？

假如n從16擴容到了32，那麼會有這樣的變化：

擴容後，n-1的高位多了一個1。

能夠發現，在擴容後不須要從新計算hash值，節省了計算時間。而通過&運算後，會多關注一個高位的bit，這個bit要麼是0，要麼是1。0表示新位置和原位置一致，保持不變；1則表示新位置是原位置加上舊容量大小。而新增的bit是0仍是1能夠認爲是隨機的，這樣在resize過程當中，能夠均勻的將以前衝突的結點分配到新bucket中。

再看下put方法：

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; // 建立table
        if ((p = tab[i = (n - 1) & hash]) == null) // 計算index
            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;
    }
複製代碼

大體流程以下：

若是當前table爲空時，調用resize方法進行初始化；
根據key的hash值計算出所在結點位置；
若是沒有發生衝突，調用newNode方法封裝key-value鍵值對，並將其掛到 table對應位置下，不然，跳轉到步驟4；
若是發生衝突：
- 若是該key已存在，更新oldValue爲新的value，並返回oldValue;
- 若是key所在的結點爲treeNode，調用紅黑樹的putTreeVal方法將該結點掛到紅黑樹上；
- 若是插入結點後，當前bucket節點下鏈表長度超過8，須要將鏈表變爲紅黑樹；
數據put完成以後，若是當前長度大於threshold，則調用resize方法擴容。

get實現

前面講了put，這裏就不得不說一下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))))
                // 命中，直接返回
                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;
    }
複製代碼