帶你走進Java集合之HashMap

時間 2019-11-08

標籤走進 java 集合 hashmap 欄目 Java 简体版

原文原文鏈接

1、概述

HashMap是一個散列表，它存儲的內容是鍵值對(key-value)映射，它是基於哈希表的 Map 接口的非同步實現。此實現提供全部可選的映射操做，並容許使用 null 值和 null 鍵。html

做爲一名java開發者，咱們日常使用過HashMap應該是比較多的，有沒有想過HashMap究竟是怎麼實現的呢？咱們使用HashMap的時候須要注意什麼嗎？怎麼使用才能使得HashMap的效率最大化呢？接下來，咱們帶着這些疑問，去讀HashMap的源碼，來揭開HashMap的神祕面紗，注意，本次閱讀的jdk源碼版本爲1.8。java

2、窺探HashMap數據結構

咱們先看看HashMap的屬性以及構造方法，對HashMap有個初步的瞭解，瞭解其是怎麼樣的數據結構實現。node

/**
    /**hashMap默認容量，1<<4=16**/
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    
    //默認最大的容量 
    static final int MAXIMUM_CAPACITY = 1 << 30;
    //默認的負載因子0.75，後續用來擴容的判斷條件
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    //鏈表轉換爲紅黑樹的閾值，默認是8
    static final int TREEIFY_THRESHOLD = 8;
    //紅黑樹轉換鏈表的閥值，默認是6
    static final int UNTREEIFY_THRESHOLD = 6;
    //進行鏈表轉換最少須要的數組長度，若是沒有達到這個數字，只能進行擴容
    static final int MIN_TREEIFY_CAPACITY = 64;
    //節點數組
    transient Node<K,V>[] table;
    //map的Entry緩存
    transient Set<Map.Entry<K,V>> entrySet;
    //map中存放的鍵值對數目
    transient int size;
    //記錄這個map數據結構發生改變的次數,用於快速失敗機制
    transient int modCount;
    //實際的負載因子
    final float loadFactor;
    //內部類，節點類
     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 int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }
        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指定容量和加載因子的構造方法
       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;
        this.threshold = tableSizeFor(initialCapacity);
    }
    //指定容量的構造方法
     public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    //默認的構造方法
     public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }
    //直接給定Map的構造方法
    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }
複製代碼

咱們閱讀完上面HashMap的構造方法以及屬性後，咱們知道HashMap最關鍵的元素有3個，第一個是容量，第二個是加載因子，第三個是Node節點的構造。HashMap默認的容量是16，也能夠指定容量進行建立,加載因子默認是0.75，當HashMap容量使用的比例達到總比例的0.75後，就進行擴容。HashMap聲明瞭一個Node節點的數組，同時，Node節點能夠指向下一個Node,因此暫時HashMap的內部數據結構大概是這樣（後續還會變化，後面會細說）：編程

知道HashMap大概數據結構後，咱們來了解下HashMap經常使用的方法，看看HashMap是如何添加，查找，刪除，擴容等操做的。數組

3、HashMap經常使用方法源碼

put(K key, V value)

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
/**真正的put方法邏輯*/
 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //若是table還沒初始化就進行擴容。
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        /**若是計算出來table數組索引[i]爲空，就直接構造新節點賦值*/
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            /**若是計算出的Hash值索引同樣，同時key也同樣，若是onlyIfAbsent爲true就忽略，不然覆蓋原來的value*/
            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) {
                    /**若是當前key對應的hash索引是最後一個的話*/
                    if ((e = p.next) == null) {
                        /**構造新的節點添加到尾部*/
                        p.next = newNode(hash, key, value, null);
                        /**若是該節點鏈表數大於等於8*/
                        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;
                /**判斷是否須要覆蓋相同key的value**/
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                /***用於支持LinkedHashMap的方法*/    
                afterNodeAccess(e);
                return oldValue;
            }
        }
        /**記錄修改次數*/
        ++modCount;
        if (++size > threshold)
        //擴容
            resize();
        /***用於支持LinkedHashMap的方法*/
        afterNodeInsertion(evict);
        return null;
    }
複製代碼

HashMap調用put方法，首先會經過Hash(key)&(table.length-1)計算出table數組的索引值，而後若是該位置若是爲null，直接new一個node，賦值便可；若是當前位置已經有元素，就判斷key是否相等，若是相等而且同時設置了onlyIfAbsent爲true,那麼就會忽略新元素（默認設置爲false）。若是key不相等，那麼構造新的node節點，放在最後一個節點的尾部，同時，若是node鏈表個數大於等於8，會進行鏈表轉紅黑樹轉換。最後若是map的size大於總size的0.75倍，就進行擴容。緩存

get(Object key)

public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }
//真正執行HashMap的get()方法
final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        //判斷若是key的索引位置不爲空
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            //判斷該位置第一個元素的key和hash值是否同樣，同樣就返回該元素
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            //若是第一個元素不是查找的key，那麼判斷鏈表是否還有元素
            if ((e = first.next) != null) {
            //若是是樹節點，執行樹節點查找方法
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                //不是樹節點，循環遍歷查找，直到查找到對應的key或者最後一個元素爲止
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }
複製代碼

HashMap的get方法相對put方法來講簡單些，首先判斷索引第一個是否是查找的key，若是不是就循環遍歷鏈表。bash

以上源碼引出來了新的內容，hash計算，紅黑樹轉換，擴容。咱們接下來分析下這三部分的內容，看看HashMap到底是如何計算索引，紅黑樹轉換和擴容的。數據結構

計算hash值

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

這裏用計算hash值並非直接求key的hashCode,而是求出HashCode值後再進行了一次操做hashcode無符號右移16位，而後與原值進行異或操做，爲何要這麼操做呢？直接解析hashcode方法計算不就能夠了嗎？這麼設計是有緣由的，咱們知道，HashMap最終計算索引位置是經過(n - 1) & hash來計算的，n就是數組的長度，該方法實際上也是對n求餘的操做，咱們知道位運算要比求餘運算要快，因此，這裏也算是一個優化。那麼爲啥求Hash值的時候須要進行右移呢？由於咱們的n,也就是table數組的長度，比較小，當進行位運算時，只有低位參與了運算，高位並無參與運算，就好比默認的n=16,換算成32位2進製爲00000000000000000000000000010000,因此，因爲n的高位所有是0，至關於作位運算沒有意義，因此，爲了讓高位也參與運算，先本身右移16位，而後和本身進行異或運算，這樣作能夠增長hash的隨機性，減小碰撞概率。咱們經過圖示來解析下：咱們假設hash值二進制爲：00101010101010101010101011111101,n爲默認的16，此時計算過程以下：app

最後結果換算成10進製爲：7，這就計算出來此時key能夠緩存的位置爲數組索引等於7的位置下。post

紅黑樹轉換

final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        //判斷table數組長度是否小於64，若是小於就進行擴容
        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節點設置爲尾部節點
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            //節點轉換完成後，肯定了頭部節點，開始進行紅黑樹轉換
            if ((tab[index] = hd) != null)
            //把普通treeNode列表轉換成爲紅黑樹
                hd.treeify(tab);
        }
    }
複製代碼

這裏的主要操做只是把普通的node節點轉換成treeNode節點，此時，仍是最開始的鏈表形式，最後的紅黑樹轉換依靠hd.treeify(tab)方法進行轉換。

final void treeify(Node<K,V>[] tab) {
            TreeNode<K,V> root = null;
            for (TreeNode<K,V> x = this, next; x != null; x = next) {
                next = (TreeNode<K,V>)x.next;
                x.left = x.right = null;
                //肯定root節點，若是root爲空，就設置當前節點爲root節點，並設置是黑節點。
                if (root == null) {
                    x.parent = null;
                    x.red = false;
                    root = x;
                }
                //若是root節點已經肯定，就開始構造紅黑樹，下面是左節點和右節點的肯定，涉及到排序。
                else {
                    K k = x.key;
                    int h = x.hash;
                    Class<?> kc = null;
                    //遍歷root，把節點x插入到紅黑樹中，執行先插入，後修正
                    for (TreeNode<K,V> p = root;;) {
                        int dir, ph;
                        K pk = p.key;
                        if ((ph = p.hash) > h)
                            dir = -1;
                        else if (ph < h)
                            dir = 1;
                        else if ((kc == null &&
                                  (kc = comparableClassFor(k)) == null) ||
                                 (dir = compareComparables(kc, k, pk)) == 0)
                        //比較k和pk的值，用於判斷是遍歷左子樹仍是右子樹
                            dir = tieBreakOrder(k, pk);

                        TreeNode<K,V> xp = p;
                        if ((p = (dir <= 0) ? p.left : p.right) == null) {
                            x.parent = xp;
                            if (dir <= 0)
                                xp.left = x;
                            else
                                xp.right = x;
                            root = balanceInsertion(root, x);
                            break;
                        }
                    }
                }
            }
            moveRootToFront(tab, root);
        }
複製代碼

以上就是一個紅黑樹樹化的一個過程，因爲篇幅緣由，後面的紅黑樹是如何旋轉等操做，這些涉及到基本的數據結構知識，就不在本文的討論之中。HashMap進行樹化後，此時真正的結構以下圖：

擴容

final Node<K,V>[] resize() {
        // 當前table保存
        Node<K,V>[] oldTab = table;
        //保存table的容量
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        //保存當前閾值
        int oldThr = threshold;
        int newCap, newThr = 0;
        //若是當前table的長度大於0
        if (oldCap > 0) {
        //當前table已是最大長度了，沒法擴容了
            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
        }
        //若是當前table大容量等於0，而且閾值大於0
        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"})
        //初始化新table數組。
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        //舊table數組不爲null,說明已經初始化過了。
        if (oldTab != null) {
        //循環遍歷舊table數組的元素
            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;
                          // 將table中的元素根據(e.hash & oldCap)是否爲0進行分割，分紅兩個不一樣的鏈表，完成從新計算hash操做
                            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;
    }
複製代碼

這裏比較難理解的就是根據(e.hash & oldCap) == 0來建立兩個鏈表，而後分別賦值在擴容後的table原來位置或者「原位置+oldCap」，這裏怎麼理解呢？由於咱們擴容使用的是2次冪擴展（也就是原來的2倍），因此擴容後的元素，從新計算hash值，元素要麼就是在原來的位置，要麼就是原來的位置再移動2次冪。咱們用一張圖來講明下這個設計機制：

圖（a）表示擴容前的key1和key2兩種key肯定索引位置的示例，圖（b）表示擴容後key1和key2兩種key肯定索引位置的示例，其中hash1是key1對應的哈希與高位運算結果。元素在從新計算hash以後，由於n變爲2倍，那麼n-1的mask範圍在高位多1bit(紅色)，所以新的index就會發生這樣的變化：

因此，擴容後只須要判斷 (e.hash & oldCap) 是否等於0就能夠知道元素再新table的位置，不須要從新計算每個元素的hash值，這裏是jdk1.8的擴容優化。上面源碼涉及紅黑樹的分割，原理和鏈表的從新分配是同樣的，一樣判斷 (e.hash & oldCap)是否爲0，來分割爲2個樹，惟一的區別就是涉及到紅黑樹的旋轉變色等操做，有興趣的同窗能夠自行閱讀，本次鑑於篇幅緣由就不分析了。

4、總結

HashMap初始化默認長度16，負載因子0.75，進行紅黑樹轉換的要求必須，鏈表個數大於8，同時，table數組的長度必須大於64，不然只能進行擴容。
HashMap只有真正執行了put方法後才進行第一次容量的肯定，這樣能夠節省空間。
HashMap計算key的hash值方法爲了減小碰撞，增長索引計算的隨機性，把hash值的高位與原hash值進行計算。
HashMap進行樹化操做，先遍歷鏈表節點，轉換爲樹節點，而後進行紅黑樹構造，先肯定根節點，而後肯定左樹和右樹，進行樹節點的插入，最後進行紅黑樹的修正（顏色變換等）
HashMap的擴容，每次擴容爲2次冪（也就是原來的2倍），擴容肯定元素的新位置只須要和原來的容量值位運算就ok了，這樣避免了從新計算全部元素的hash值操做。