淺析HashMap源碼（1）

時間  2019-11-11
標籤 淺析 hashmap 源碼 简体版
原文   原文鏈接

前言

本文的目的是閱讀理解HashMap的源碼，做爲集合中重要的一個角色，平時用到十分多的一個類，深刻理解它，知其因此然很重要。本文基於Jdk1.7，由於Jdk1.8改變了HashMap的數據結構，進行了優化，咱們先從基礎閱讀，以後再閱讀理解Jdk1.8的內容數組

HashMap的特性

1.經過key-value的形式快速的存取元素
2.容許鍵爲Null，但只容許有一個鍵的值爲Null
3.線程不安全
4.底層結構是Hash表，元素是無序的
5.再不考慮Hash衝突的時候，插入和查詢的複雜度是能夠達到O（1）的安全

HashMap的數據結構

底層數據結構是一個Hash表，基於數組和鏈表，數組裏面保存着一個單向鏈表的頭節點，單項鍊表保存着具備相同Hash值的不一樣元素，再不發生Hash衝突的狀況下，鏈表應該只有一個元素，這是最理想的狀態。數據結構

clipboard.png
鏈表的數據結構代碼
`函數

static class Entry<K, V> implements Map.Entry<K, V> {
final K key;
V value;
Entry<K, V> next;    // 下一個Entry對象的引用
int hash;    // 其實就是key的hash值  
}

HashMap的常量結構

// 默認初始化容量 16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
 
// HashMap容許的最大容量 2^30
static final int MAXIMUM_CAPACITY = 1 << 30;
 
// 默認的負載率 75%
static final float DEFAULT_LOAD_FACTOR = 0.75f;
 
// 空的哈希表
static final Entry<?, ?>[] EMPTY_TABLE = {};
 
// 實際使用的哈希表
transient Entry<K, V>[] table = (Entry<K, V>[]) EMPTY_TABLE;
 
// HashMap的大小,即存儲的key-value的數量
transient int size;
 
// 擴容的閥值，當HashMap的size達到閥值時，就開始擴容 threshold=length*threshold 
int threshold;
 
// 負載率
final float loadFactor;
 
// 修改次數, 用於fail-fast機制
transient int modCount;
 
// 替代哈希使用的默認擴容閥值
static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;
 
// 隨機的哈希種子, 有助於減小發生哈希碰撞的概率

transient int hashSeed = 0;

HashMap的初始化

HashMap的初始化涉及到上面的多個常量，在瞭解完常量的做用以後，咱們就能夠理解HashMap的初始化思想，首先，HashMap並非經過構造函數來初始化的，構造函數只是初始化HashMap的初始化參數，包括DEFAULT_INITIAL_CAPACITY ，loadFactor等，再初始化參數以後，真正的調用Put方法時，會判斷table 是否已經初始化，沒有的話再根據參數進行初始化。性能

put方法的流程咱們這邊也要先理解：
（1）檢查哈希表是不是個空表，若是是空表就調用inflateTable方法進行初始化
（2）判斷key是否爲null，若是爲null，就調用putForNullKey方法, 將key爲null的key-value存儲在哈希表的第一個位置中
若是key不爲null，則調用hash方法計算key的hash值
（3）根據hash值和Entry數組的長度定位到Entry數組的指定槽位
（4）判斷Entry數組指定槽位的值e是否爲null, 若是e不爲null, 則遍歷e指向的單鏈表, 若是傳入的key在單鏈表中已經存在了, 就進行替換操做, 不然就新建一個Entry並添加到單鏈表的表頭位置
（5）若是e爲null, 就新建一個Entry並添加到指定槽位優化

下面是代碼：
構造方法this

public HashMap(int initialCapacity, float loadFactor) {
    // 若是初始容量小於0，則拋出異常
    if (initialCapacity < 0) {
        throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
    }
 
    // 若是初始容量大於容量最大值，則使用最大值做爲初始容量
    if (initialCapacity > MAXIMUM_CAPACITY) { initialCapacity = MAXIMUM_CAPACITY; }
 
    // 若是負載率小於等於0或負載率不是浮點數，則拋出異常
    if (loadFactor <= 0 || Float.isNaN(loadFactor)) {
        throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
    }
 
    // 設置負載率
    this.loadFactor = loadFactor;
 
    // 設置閥值爲初始容量
    threshold = initialCapacity;
 
    // 空實現, 交由子類實現
    init();
}
//

初始化數組方法spa

private void inflateTable(int toSize) {
    // 尋找大於toSize的,最小的,2的n次方做爲新的容量
    int capacity = roundUpToPowerOf2(toSize);
 
    // 閥值=容量*負載因子, 若是容量*負載因子>最大容量時, 閥值=最大容量
    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
 
    // 按新的容量建立一個新的數組
    table = new Entry[capacity];
 
    // 從新初始化hashSeed
    initHashSeedAsNeeded(capacity);
}

put方法線程

public V put(K key, V value) {
    // 若是哈希表沒有初始化就進行初始化
    if (table == EMPTY_TABLE) {
        // 初始化哈希表
        inflateTable(threshold);
    }
 
    // 當key爲null時，調用putForNullKey方法，保存null於table的第一個位置中，這是HashMap容許爲null的緣由
    if (key == null) {
        return putForNullKey(value);
    }
 
    // 計算key的hash值
    int hash = hash(key);
    // 根據key的hash值和數組的長度定位到entry數組的指定槽位
    int i = indexFor(hash, table.length);
    // 獲取存放位置上的entry，若是該entry不爲空，則遍歷該entry所在的鏈表
    for (Entry<K, V> e = table[i]; e != null; e = e.next) {
        Object k;
        // 經過key的hashCode和equals方法判斷，key是否存在， 若是存在則用新的value取代舊的value，並返回舊的value
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }
 
    // 修改次數增長1
    modCount++;
    // 若是找不到鏈表 或者 遍歷完鏈表後，發現key不存在，則建立一個新的Entry，並添加到HashMap中
    addEntry(hash, key, value, i);
    return null;
}

 void addEntry(int hash, K key, V value, int bucketIndex) {
    //添加key到table[bucketIndex]位置，新的元素老是在table[bucketIndex]的第一個元素，原來的元素後移
    Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
    //判斷元素個數是否達到了臨界值，若已達到臨界值則擴容，table長度翻倍
        if (size++ >= threshold)
            resize(2 * table.length);
    }

HashMap的查

當key值爲Null的時候會進行特殊處理，在table[0]的鏈表上查找Key爲null的元素，get的過程是：
（1）計算hash與table.length取模計算index值
（2）遍歷table[index]上的鏈表，直到找到key設計

void addEntry(int hash, K key, V value, int bucketIndex) {
//添加key到table[bucketIndex]位置，新的元素老是在table[bucketIndex]的第一個元素，原來的元素後移
Entry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
//判斷元素個數是否達到了臨界值，若已達到臨界值則擴容，table長度翻倍
    if (size++ >= threshold)
        resize(2 * table.length);
}

#HashMap的刪
remove方法一樣也是，先計算hash,在計算index，遍歷查找，找到以後刪除節點

/**
     * 根據key刪除元素
     */
    public V remove(Object key) {
        Entry<K,V> e = removeEntryForKey(key);
        return (e == null ? null : e. value);
    }

    /**
     * 根據key刪除鏈表節點
     */
    final Entry<K,V> removeEntryForKey(Object key) {
        // 計算key的hash值
        int hash = (key == null) ? 0 : hash(key.hashCode());
        // 根據hash值計算key在數組的索引位置
        int i = indexFor(hash, table.length );
        // 找到該索引出的第一個節點
        Entry<K,V> prev = table[i];
        Entry<K,V> e = prev;

        // 遍歷鏈表（從鏈表第一個節點開始next），找出相同的key，
        while (e != null) {
            Entry<K,V> next = e. next;
            Object k;
            // 若是hash值和key都相等，則認爲相等
            if (e.hash == hash &&
                ((k = e. key) == key || (key != null && key.equals(k)))) {
                // 修改版本+1
                modCount++;
                // 計數器減1
                size--;
                // 若是第一個就是要刪除的節點（第一個節點沒有上一個節點，因此要分開判斷）
                if (prev == e)
                    // 則將下一個節點放到table[i]位置（要刪除的節點被覆蓋）
                    table[i] = next;
                else
                 // 不然將上一個節點的next指向當要刪除節點下一個（要刪除節點被忽略，沒有指向了）
                    prev. next = next;
                e.recordRemoval( this);
                // 返回刪除的節點內容
                return e;
            }
            // 保存當前節點爲下次循環的上一個節點
            prev = e;
            // 下次循環
            e = next;
        }

        return e;
}

HashMap的擴容

resize擴容是HashMap中很是重要的一個操做，在容器裏的元素達到一個臨界值時，HashMap會自動進行擴容，擴容的具體流程是；
1.在put的時候檢查是否須要擴容，根據兩個參數：初始容量和裝載因子
2.建立一個容量爲table.length*2的table，修改臨界值
3.從新計算全部元素的hash值，並放入新的table，使用的是頭插法
4.用新的table替換舊的table

void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {//最大容量爲 1 << 30
            threshold = Integer.MAX_VALUE;
            return;
        }

        Entry[] newTable = new Entry[newCapacity];//新建一個新表
        boolean oldAltHashing = useAltHashing;
        useAltHashing |= sun.misc.VM.isBooted() &&
                (newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        boolean rehash = oldAltHashing ^ useAltHashing;//是否再hash
        transfer(newTable, rehash);//完成舊錶到新表的轉移
        table = newTable;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }
--------------------- 
 void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        for (Entry<K,V> e : table) {//遍歷同桶數組中的每個桶
            while(null != e) {//順序遍歷某個桶的外掛鏈表
                Entry<K,V> next = e.next;//引用next
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity);//找到新表的桶位置;原桶數組中的某個桶上的同一鏈表中的Entry此刻可能被分散到不一樣的桶中去了，有效的緩解了哈希衝突。
                e.next = newTable[i];//頭插法插入新表中
                newTable[i] = e;
                e = next;
            }
        }
    }

擴容的總體操做如上，可是有一些十分精妙的細節十分厲害

爲何擴容的容量必定是2的冪？

這麼設計固然是爲了性能，並且是十分顯著的性能提高，涉及到了位操做，我以爲很是有意思，會在下一篇專門講這樣計算進行提高性能的例子。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程