hashMap的實現原理解析

聊到HashMap我們通常會聯繫到HashTable，那麼就讓先來說一下他們們的區別。

下面有些是看別人分享的路徑是：http://blog.csdn.net/vking_wang/article/details/14166593   加上自己的總結。

HashMap和Hashtable的區別

HashMap和Hashtable都實現了Map接口，但決定用哪一個之前先要弄清楚它們之間的分別。主要的區別有：線程安全性，同步(synchronization)，以及速度。

• HashMap幾乎可以等價於Hashtable，除了HashMap是非synchronized的，並可以接受null(HashMap可以接受爲null的鍵值(key)和值(value)，而Hashtable則不行)。
• HashMap是非synchronized，而Hashtable是synchronized，這意味着Hashtable是線程安全的，多個線程可以共享一個Hashtable；而如果沒有正確的同步的話，多個線程是不能共享HashMap的。Java 5提供了ConcurrentHashMap，它是HashTable的替代，比HashTable的擴展性更好。
• 另一個區別是HashMap的迭代器(Iterator)是fail-fast迭代器，而Hashtable的enumerator迭代器不是fail-fast的。所以當有其它線程改變了HashMap的結構（增加或者移除元素），將會拋出ConcurrentModificationException，但迭代器本身的remove()方法移除元素則不會拋出ConcurrentModificationException異常。但這並不是一個一定發生的行爲，要看JVM。這條同樣也是Enumeration和Iterator的區別。
• 由於Hashtable是線程安全的也是synchronized，所以在單線程環境下它比HashMap要慢。如果你不需要同步，只需要單一線程，那麼使用HashMap性能要好過Hashtable。
• HashMap不能保證隨着時間的推移Map中的元素次序是不變的。

總結的來說：

        Hashtable和HashMap有幾個主要的不同：線程安全以及速度。僅在你需要完全的線程安全的時候使用Hashtable，而如果你使用Java 5或以上的話，請使用ConcurrentHashMap吧。HashMap可以通過下面的語句進行同步：Map m=Collections.synchronizeMap(hashMap);

        HashMap基於hashing原理，我們通過put()和get()方法儲存和獲取對象。當我們將鍵值對傳遞給put()方法時，它調用鍵對象的hashCode()方法來計算hashcode，讓後找到bucket位置來儲存值對象。當獲取對象時，通過鍵對象的equals()方法找到正確的鍵值對，然後返回值對象。HashMap使用鏈表來解決碰撞問題，當發生碰撞了，對象將會儲存在鏈表的下一個節點中。 HashMap在每個鏈表節點中儲存鍵值對對象。

        當兩個不同的鍵對象的hashcode相同時會發生什麼？ 它們會儲存在同一個bucket位置的鏈表中。鍵對象的equals()方法用來找到鍵值對。

下面解析一下HashMap的實現原理

首先看一下圖片

       從上圖我們可以發現哈希表是由數組+鏈表組成的，一個長度爲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[]裏面。

1）put

       這裏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;

}

當我們調用get()方法，HashMap會使用鍵對象的hashcode找到bucket位置，然後獲取值對象。如果兩個鍵的hashcode相同，將會遍歷鏈表直到找到值對象。根據HashMap在鏈表中存儲的是鍵值對獲取。

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();

    }

如果上面的已經理解了那麼下面的一些問題就迎刃而解了：

你知道HashMap的工作原理嗎？

你知道HashMap的get()方法的工作原理嗎？

當兩個對象的hashcode相同會發生什麼？

如果兩個鍵的hashcode相同，你如何獲取值對象？

如果HashMap的大小超過了負載因子(load factor)定義的容量，怎麼辦？

（可能有些人不知道，我來說一下：除非你真正知道HashMap的工作原理，否則你將回答不出這道題。默認的負載因子大小爲0.75，也就是說，當一個map填滿了75%的bucket時候，和其它集合類(如ArrayList等)一樣，將會創建原來HashMap大小的兩倍的bucket數組，來重新調整map的大小，並將原來的對象放入新的bucket數組中。這個過程叫作rehashing，因爲它調用hash方法找到新的bucket位置。）

你瞭解重新調整HashMap大小存在什麼問題嗎？

（當重新調整HashMap大小的時候，確實存在條件競爭，因爲如果兩個線程都發現HashMap需要重新調整大小了，它們會同時試着調整大小。在調整大小的過程中，存儲在鏈表中的元素的次序會反過來，因爲移動到新的bucket位置的時候，HashMap並不會將元素放在鏈表的尾部，而是放在頭部，這是爲了避免尾部遍歷(tail traversing)。如果條件競爭發生了，那麼就死循環了。這個時候，你可以質問面試官，爲什麼這麼奇怪，要在多線程的環境下使用HashMap呢？：）

爲什麼String, Interger這樣的wrapper類適合作爲鍵？

（String, Interger這樣的wrapper類作爲HashMap的鍵是再適合不過了，而且String最爲常用。因爲String是不可變的，也是final的，而且已經重寫了equals()和hashCode()方法了。其他的wrapper類也有這個特點。不可變性是必要的，因爲爲了要計算hashCode()，就要防止鍵值改變，如果鍵值在放入時和獲取時返回不同的hashcode的話，那麼就不能從HashMap中找到你想要的對象。不可變性還有其他的優點如線程安全。如果你可以僅僅通過將某個field聲明成final就能保證hashCode是不變的，那麼請這麼做吧。因爲獲取對象的時候要用到equals()和hashCode()方法，那麼鍵對象正確的重寫這兩個方法是非常重要的。如果兩個不相等的對象返回不同的hashcode的話，那麼碰撞的機率就會小些，這樣就能提高HashMap的性能。）

我們可以使用CocurrentHashMap來代替Hashtable嗎？

（這是另外一個很熱門的面試題，因爲ConcurrentHashMap越來越多人用了。我們知道Hashtable是synchronized的，但是ConcurrentHashMap同步性能更好，因爲它僅僅根據同步級別對map的一部分進行上鎖。ConcurrentHashMap當然可以代替HashTable，但是HashTable提供更強的線程安全性。看看這篇博客查看Hashtable和ConcurrentHashMap的區別。）