Java集合框架之三：HashMap源碼解析

 

版權聲明：本文為博主原創文章，轉載請注明出處，歡迎交流學習！

      HashMap在我們的工作中應用的非常廣泛，在工作面試中也經常會被問到，對於這樣一個重要的集合模型我們有必要弄清楚它的使用方法和它底層的實現原理。HashMap是通過key-value鍵值對的方式來存儲數據的，通過put、get方法實現鍵值對的快速存取，這是HashMap最基本的用法。HashMap底層是通過數組和鏈表相結合的混合結構來存放數據的。我們通過分析底層源碼來詳細了解一下HashMap的實現原理。

      1、HashMap的初始化

      在HashMap實例化時我們要了解兩個概念：初始容量和加載因子。HashMap是基於哈希表的Map接口實現，初始容量是哈希表在創建時的容量。加載因子是哈希表在其容量自動增加之前可以達到多滿的一種尺度。當哈希表中的條目數超過了加載因子與當前容量的乘積時，則要對該哈希表進行rehash操作（即重建內部數據結構），從而哈希表將具有大約兩倍於當前容量的新的容量。

       

       以上是Java API中HashMap的構造方法，其源碼如下：

       

static final int DEFAULT_INITIAL_CAPACITY = 16;//默認初始容量16
static final int MAXIMUM_CAPACITY = 1 << 30;//定義最大容量
static final float DEFAULT_LOAD_FACTOR = 0.75f;//默認負載因子0.75
transient Entry[] table;
int threshold; //臨界值，值為容量與加載因子的乘積
final float loadFactor; //加載因子

public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        init();
    }

void init() {
    }

 

       以上構造方法定義了一個空的HashMap，其默認初始容量為16，默認初始加載因子為0.75，同時聲明了一個Entry類型的數組，數組初始長度為16。那么這里出現的Entry對象是如何定義的呢？看一下它的實現代碼：

       

    static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next; //指向下一個Entry節點
        final int hash; //哈希值

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

        public final K getKey() {
            return key;
        }

        public final V getValue() {
            return value;
        }

        public final V setValue(V newValue) {
        V oldValue = value;
            value = newValue;
            return oldValue;
        }
        //重寫equals方法，判斷兩個Entry是否相等，如果兩個Entry對象的key和value相等，則返回true，否則返回false
        public final boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry e = (Map.Entry)o;
            Object k1 = getKey();
            Object k2 = e.getKey();
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {
                Object v1 = getValue();
                Object v2 = e.getValue();
                if (v1 == v2 || (v1 != null && v1.equals(v2)))
                    return true;
            }
            return false;
        }
        //重寫hashCode方法，返回key的hashCode值與value的hashCode值異或運算所得的值
        public final int hashCode() {
            return (key==null   ? 0 : key.hashCode()) ^
                   (value==null ? 0 : value.hashCode());
        }
        //重寫toString方法，返回此Entry對象的“key=value”映射關系
        public final String toString() {
            return getKey() + "=" + getValue();
        }

        /**
         * This method is invoked whenever the value in an entry is
         * overwritten by an invocation of put(k,v) for a key k that's already
         * in the HashMap.
         */
        void recordAccess(HashMap<K,V> m) {  //當向HashMap中添加鍵值對時，會調用此方法，這里方法體為空，即不做處理
        }

        /**
         * This method is invoked whenever the entry is
         * removed from the table.
         */
        void recordRemoval(HashMap<K,V> m) {   //當向HashMap中刪除鍵值對映射關系時，會調用此方法，這里方法體為空，即不做處理
        }
    }

       Entry類是HashMap的內部類，其實現了Map.Entry接口。Entry類里定義了4個屬性：Object類型的key、value(K、V類型可以看成Object類型)，Entry類型的next屬性（這個next其實就是一個指向下一個Entry對象的引用，形成了一個鏈表，通過此Entry對象的next屬性可以找到其下一個Entry對象）和int型的hash值。HashMap底層維護的就是一個個Entry對象。在Entry類里還重寫了equals方法，若兩個Entry的key和value都相等，則返回true，否則返回false，同時還重寫了hashCode方法。

       2、HashMap的底層數據結構

       前面提到過HashMap的底層是基於數組和鏈表來實現的，那么如何決定一個Entry對象是存放在數組中的哪個位置的呢？它是通過計算hash值來決定存儲位置的，同時在查找元素的時候同樣也是計算出一個值來找到對應的位置，因此它具有相當快的查詢速度。HashMap是根據key的hashCode值來計算hash值的，相同的hashCode值計算出來的hash值也是相同的。當存儲的對象達到了一定數量，就有可能出現不同對象的key的hashCode值是相同的，因此計算出來的hash值也相同，這樣就出現了沖突。哈希沖突的解決方法有很多，比如再哈希法，這種方法是同時構造多個不同的哈希函數，當發生沖突時就換另外的函數重新計算hash值，直到不再產生沖突為止。HashMap是通過單鏈表來解決哈希沖突的，這種方法也被稱為拉鏈法。如圖所示：

                              

       在上圖中，左邊的部分是哈希表（也稱為哈希數組），右邊是一個單鏈表，單鏈表是用來解決哈希沖突的，數組里的每一個元素都是一個單鏈表的頭節點，當不同的key計算出的數組中的存放位置相同時，就將此對象添加到單鏈表中。

       3、數據存儲

       在HashMap中定義了put方法來向集合中添加數據，數據以鍵值對的形式存儲，put方法的實現如下：

       

public V put(K key, V value) {
          //如果存入HashMap的key為null，則將該鍵值對添加到table[0]中
        if (key == null)
            return putForNullKey(value);
        //key不為null，調用hash方法計算key的hashCode值對應的hash值
        int hash = hash(key.hashCode());
        //根據計算出的hash值，結合數組的長度計算出數組中的插入位置i
        int i = indexFor(hash, table.length);
        //遍歷數組下標為i處的鏈表，如果鏈表上存在元素，其hash值與上述計算得到的hash值相等，
        //並且其key值與新增的鍵值對的key值相等，那么就以新增鍵值對的value替換此元素的value值，
        //並返回此元素原來的value
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++; //操作次數加1
        //如果鏈表上不存在滿足條件的元素，則將鍵值對對應生成的Entry對象添加到table[i]處，
        //並將下標為i處原先的Entry對象鏈接到新的Entry對象后面
        addEntry(hash, key, value, i);
        return null;
    }



private V putForNullKey(V value) {
         //遍歷數組下標為0處的鏈表，如果鏈表中存在元素其key為null，則用value覆蓋此元素原來的value
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++; //操作數加1
        //如果鏈表中不存在滿足條件的元素，則將此鍵值對生成的Entry對象存放到table[0]
        addEntry(0, null, value, 0);//key為null，計算出的hash值為0
        return null;
    }


//計算hash值
static int hash(int h) {
        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }



//根據hash值和數組長度，計算出在數組中的索引位置 
    static int indexFor(int h, int length) {
        return h & (length-1); //計算出的值不會超出數組的長度
    }



void addEntry(int hash, K key, V value, int bucketIndex) {
          //獲取table[bucketIndex]處的Entry對象
          Entry<K,V> e = table[bucketIndex];
          //根據key-value生成新的Entry對象，並將新的Entry對象存入table[bucketIndex]處，將其next引用指向原來的對象
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
        //如果數組容量大於或等於臨界值，則進行擴容
        if (size++ >= threshold)
            resize(2 * table.length); //容量為原來的2倍
    }

       以上就是put方法的實現原理，我給出了詳細的代碼注釋。上面已經講到過HashMap底層的數據結構是由數組和單向鏈表構成的，當我們向HashMap中put一對key-value鍵值對時，首先判斷key是否為null，如果為null，則遍歷table[0]處的鏈表，若此鏈表上存在key為null的元素，則用value覆蓋此元素的value值，如果不存在這樣的元素，那么將此鍵值對生成的Entry對象存放到table[0]中；如果key不為null，首先根據key的hashCode值計算出hash值，根據hash值和數組長度計算出要存放到數組中的位置i，然后遍歷table[i]處的鏈表，如果鏈表上存在元素其hash值與計算得到的hash值相等並且其key值與新增的key相等，那么就以新增的value覆蓋此元素原來的value並返回原來的value值；如果鏈表上不存在滿足上面條件的元素，則將key-value生成的Entry對象存放到table[i]處，並將其next指向此處原來的Entry對象。這樣經過多次put操作，就構成了數組加鏈表的存儲結構。

       4、數據讀取

       HashMap的get方法可以根據key返回其對應的value，如果key為null，則返回null。

       

public V get(Object key) {
          //如果key為null，則循環table[0]處的單鏈表
        if (key == null)
            return getForNullKey();
        //key不為null，根據key的hashCode計算出一個hash值    
        int hash = hash(key.hashCode());
        //根據hash值和數組長度計算出一個數組下標值，並且遍歷此下標處的單鏈表
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            //如果Entry對象的hash值跟上面計算得到的hash值相等，並且key也相等，那么就返回此Entry對象value
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;
        }
        //如果單鏈表上不存在滿足上述條件的Entry對象，則表明HashMap不包含該key的映射關系，返回null
        return null;
    }



private V getForNullKey() {
          //獲取table[0]處的Entry對象，並循環其鏈接的單鏈表，如果單鏈表上存在不為null的對象，
          //並且其key為null，那么就返回此對象的value
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        //如果單鏈表上不存在滿足條件的對象，則返回null
        return null;
    }

       了解了put方法的原理，我們就不難理解get的實現原理了，與之類似也是要根據key的hashCode值來計算出一個hash值，然后根據hash值和數組長度計算出一個數組下標值，接着循環遍歷此下標處的單鏈表，尋找滿足條件的Entry對象並返回value，此value就是HashMap中該key所映射的value。注意分析當key為null時的情況：如果HashMap中有key為null的映射關系，那么就返回null映射的value，否則就表明HashMap中不存在key為null的映射關系，返回null。同理，當get方法返回的值為null時，並不一定表明該映射不包含該鍵的映射關系，也可能是該映射將該鍵顯示的映射為null，即put(key, null)。可使用containKey方法來區分這兩種情況。

       5、移除映射關系

       remove方法根據指定的key從HashMap映射中移除相應的映射關系（如果存在），此方法返回一個value。

       

public V remove(Object key) {
        Entry<K,V> e = removeEntryForKey(key);
        return (e == null ? null : e.value);
    }



final Entry<K,V> removeEntryForKey(Object key) {
          //根據key的hashCode計算hash值
        int hash = (key == null) ? 0 : hash(key.hashCode());
        //根據hash值和數組長度計算數組下標值i
        int i = indexFor(hash, table.length);
        //獲取下標為i處的數組元素
        Entry<K,V> prev = table[i];
        Entry<K,V> e = prev;
        //遍歷數組下標為i處的單鏈表
        while (e != null) {
            Entry<K,V> next = e.next;
            Object k;
            //如果此單鏈表上存在Entry對象e，其hash值與計算出的hash值相等並且其key也跟傳入的key"相等"，則從單鏈表上移除e
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {
                modCount++;
                size--; //map中的映射數減1
                //判斷滿足條件的Entry對象是在數組下標i處還是在數組外面的單鏈表上
                if (prev == e)
                    table[i] = next;
                else
                    prev.next = next;
                e.recordRemoval(this);
                return e;
            }
            prev = e;
            e = next;
        }

        return e;
    }

       從上面的源碼可以看出，remove方法的原理是先找出滿足條件的Entry對象，然后從單鏈表上刪除該對象，並返回該對象中的value，本質上是對單鏈表的操作。

       6、總結

       從以上源碼的分析中我們知道了HashMap底層維護的是數組加鏈表的混合結構，這是HashMap的核心，只要掌握了這一點我們就能很容易弄清楚HashMap中映射關系的各種操作原理，其本質是對數組和鏈表的操作。要注意的是HashMap不是線程安全的，我們可以使用Collections.synchoronizedMap方法來獲得線程安全的HashMap。例如：

       Map map = Collections.sychronizedMap(new HashMap());

       以上是我個人對HashMap底層原理的一點理解，不妥的地方歡迎指正！