[轉]Java HashMap實現原理與源碼分析

標籤：

1. HashMap的資料結構

資料結構中有數組和鏈表來實現對資料的儲存，但這兩者基本上是兩個極端。

      數組

數組儲存區間是連續的，佔用記憶體嚴重，故空間複雜的很大。但數組的二分尋找時間複雜度小，為O(1)；數組的特點是：定址容易，插入和刪除困難；

鏈表

鏈表格儲存體區間離散，佔用記憶體比較寬鬆，故空間複雜度很小，但時間複雜度很大，達O（N）。鏈表的特點是：定址困難，插入和刪除容易。

雜湊表

那麼我們能不能綜合兩者的特性，做出一種定址容易，插入刪除也容易的資料結構？答案是肯定的，這就是我們要提起的雜湊表。雜湊表（(Hash table）既滿足了資料的尋找方便，同時不佔用太多的內容空間，使用也十分方便。

　　雜湊表有多種不同的實現方法，我接下來解釋的是最常用的一種方法—— 拉鏈法，我們可以理解為“鏈表的數組” ，

 

 

　　從我們可以發現雜湊表是由數組+鏈表組成的，一個長度為16的數組中，每個元素儲存的是一個鏈表的頭結點。那麼這些元素是按照什麼樣的規則儲存到數組中呢。一般情況是通過hash(key)%len獲得，也就是元素的key的雜湊值對數組長度模數得到。比如上述雜湊表中，12%16=12,28%16=12,108%16=12,140%16=12。所以12、28、108以及140都儲存在數組下標為12的位置。

　　HashMap其實也是一個線性數組實現的,所以可以理解為其儲存資料的容器就是一個線性數組。這可能讓我們很不解，一個線性數組怎麼實現按索引值對來存取資料呢？這裡HashMap有做一些處理。

　　首先HashMap裡面實現一個靜態內部類Entry，其重要的屬性有 key , value, next，從屬性key,value我們就能很明顯的看出來Entry就是HashMap索引值對實現的一個基礎bean，我們上面說到HashMap的基礎就是一個線性數組，這個數組就是Entry[]，Map裡面的內容都儲存在Entry[]裡面。

  

  /**     * The table, resized as necessary. Length MUST Always be a power of two.     */    transient Entry[] table;

2. HashMap的存取實現

     既然是線性數組，為什麼能隨機存取？這裡HashMap用了一個小演算法，大致是這樣實現：

// 儲存時:int hash = key.hashCode(); // 這個hashCode方法這裡不詳述,只要理解每個key的hash是一個固定的int值int index = hash % Entry[].length;Entry[index] = value;// 取值時:int hash = key.hashCode();int index = hash % Entry[].length;return Entry[index];

1）put 疑問：如果兩個key通過hash%Entry[].length得到的index相同，會不會有覆蓋的危險？

　　這裡HashMap裡面用到鏈式資料結構的一個概念。上面我們提到過Entry類裡面有一個next屬性，作用是指向下一個Entry。打個比方， 第一個索引值對A進來，通過計算其key的hash得到的index=0，記做:Entry[0] = A。一會後又進來一個索引值對B，通過計算其index也等於0，現在怎麼辦？HashMap會這樣做:B.next = A,Entry[0] = B,如果又進來C,index也等於0,那麼C.next = B,Entry[0] = C；這樣我們發現index=0的地方其實存取了A,B,C三個索引值對,他們通過next這個屬性連結在一起。所以疑問不用擔心。也就是說數組中儲存的是最後插入的元素。到這裡為止，HashMap的大致實現，我們應該已經清楚了。

 

public V put(K key, V value) {        if (key == null)            return putForNullKey(value); //null總是放在數組的第一個鏈表中        int hash = hash(key.hashCode());        int i = indexFor(hash, table.length);        //遍曆鏈表        for (Entry<K,V> e = table[i]; e != null; e = e.next) {            Object k;            //如果key在鏈表中已存在，則替換為新value            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {                V oldValue = e.value;                e.value = value;                e.recordAccess(this);                return oldValue;            }        }         modCount++;        addEntry(hash, key, value, i);        return null;    } void addEntry(int hash, K key, V value, int bucketIndex) {    Entry<K,V> e = table[bucketIndex];    table[bucketIndex] = new Entry<K,V>(hash, key, value, e); //參數e, 是Entry.next    //如果size超過threshold，則擴充table大小。再散列    if (size++ >= threshold)            resize(2 * table.length);}

　　當然HashMap裡面也包含一些最佳化方面的實現，這裡也說一下。比如：Entry[]的長度一定後，隨著map裡面資料的越來越長，這樣同一個index的鏈就會很長，會不會影響效能？HashMap裡面設定一個因子，隨著map的size越來越大，Entry[]會以一定的規則加長長度。

2）get

 public V get(Object key) {        if (key == null)            return getForNullKey();        int hash = hash(key.hashCode());        //先定位到數組元素，再遍曆該元素處的鏈表        for (Entry<K,V> e = table[indexFor(hash, table.length)];             e != null;             e = e.next) {            Object k;            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))                return e.value;        }        return null;}

3）null key的存取

null key總是存放在Entry[]數組的第一個元素。

 

private V putForNullKey(V 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++;        addEntry(0, null, value, 0);        return null;    }     private V getForNullKey() {        for (Entry<K,V> e = table[0]; e != null; e = e.next) {            if (e.key == null)                return e.value;        }        return null;    }  

4）確定數組index：hashcode % table.length模數

HashMap存取時，都需要計算當前key應該對應Entry[]數組哪個元素，即計算數組下標；演算法如下：

  

 /**     * Returns index for hash code h.     */    static int indexFor(int h, int length) {        return h & (length-1);    }

 按位取並，作用上相當於模數mod或者取餘%。這意味著數組下標相同，並不表示hashCode相同。 5）table初始大小 

 public HashMap(int initialCapacity, float loadFactor) {        .....         // Find a power of 2 >= initialCapacity        int capacity = 1;        while (capacity < initialCapacity)            capacity <<= 1;         this.loadFactor = loadFactor;        threshold = (int)(capacity * loadFactor);        table = new Entry[capacity];        init();    }

　　

注意table初始大小並不是建構函式中的initialCapacity！！

而是 >= initialCapacity的2的n次冪！！！！

————為什麼這麼設計呢？——

3. 解決hash衝突的辦法

1. 開放定址法（線性探測再散列，二次探測再散列，偽隨機探測再散列）
2. 再雜湊法
3. 鏈地址法
4. 建立一個公用溢出區

Java中hashmap的解決辦法就是採用的鏈地址法。

 

4. 再散列rehash過程

當雜湊表的容量超過預設容量時，必須調整table的大小。當容量已經達到最大可能值時，那麼該方法就將容量調整到Integer.MAX_VALUE返回，這時，需要建立一張新表，將原表的映射到新表中。

   

/**     * Rehashes the contents of this map into a new array with a     * larger capacity.  This method is called automatically when the     * number of keys in this map reaches its threshold.     *     * If current capacity is MAXIMUM_CAPACITY, this method does not     * resize the map, but sets threshold to Integer.MAX_VALUE.     * This has the effect of preventing future calls.     *     * @param newCapacity the new capacity, MUST be a power of two;     *        must be greater than current capacity unless current     *        capacity is MAXIMUM_CAPACITY (in which case value     *        is irrelevant).     */    void resize(int newCapacity) {        Entry[] oldTable = table;        int oldCapacity = oldTable.length;        if (oldCapacity == MAXIMUM_CAPACITY) {            threshold = Integer.MAX_VALUE;            return;        }         Entry[] newTable = new Entry[newCapacity];        transfer(newTable);        table = newTable;        threshold = (int)(newCapacity * loadFactor);    }

  /**     * Transfers all entries from current table to newTable.     */    void transfer(Entry[] newTable) {        Entry[] src = table;        int newCapacity = newTable.length;        for (int j = 0; j < src.length; j++) {            Entry<K,V> e = src[j];            if (e != null) {                src[j] = null;                do {                    Entry<K,V> next = e.next;                    //重新計算index                    int i = indexFor(e.hash, newCapacity);                    e.next = newTable[i];                    newTable[i] = e;                    e = next;                } while (e != null);            }        }    }

 

轉自 HashMap實現原理分析

[轉]Java HashMap實現原理與源碼分析