HashMap源碼解析

　　HashMap繼承AbstractMap,實現了Map接口,Map接口定義了所有Map子類必須實現的方法。

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable

　　HashMap的實例有兩個參數影響其性能：初始容量和加載因子。初始容量只是哈希表在創建時的容量。加載因子是哈希表再其容量自動增加之前可以達到多滿的一種尺度。當哈希表中的條目數超出了加載因子與當前容量的乘積時，則要對該哈希表進行rehash操作（擴容操作）。

　　HashMap中定義的屬性：

    /**
      * 默認的初始容量16.
      */
     static final int DEFAULT_INITIAL_CAPACITY = 16;
     /**
      * 最大容量
      */
     static final int MAXIMUM_CAPACITY = 1 << 30;
     /**
      * 默認裝載因子0.75f.
      */
     static final float DEFAULT_LOAD_FACTOR = 0.75f;
     /**
      * 存儲數據的Entry數組
      */
     transient Entry[] table;
     /**
      * map中保存的鍵值對的數量
      */
     transient int size;
     /**
      * 需要調整大小的極限值（容量*裝載因子）
      */
     int threshold;
     /**
      *裝載因子,當HashMap的數據大小>=容量*加載因子時，HashMap會將容量擴容
      */
     final float loadFactor;
     /**
      * map結構被改變的次數
      */
     transient volatile int modCount;

　　HashMap的構造方法。

    /**
     *使用默認的容量及裝載因子構造一個空的HashMap
     */
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        table = new Entry[DEFAULT_INITIAL_CAPACITY];//根據默認容量（16）初始化table
        init();
    }
　　/**
     * 根據給定的初始容量的裝載因子創建一個空的HashMap
     * 初始容量小於0或裝載因子小於等於0將報異常 
     */
    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);
        int capacity = 1;
        //設置capacity為大於initialCapacity且是2的冪的最小值
        while (capacity < initialCapacity)
            capacity <<= 1;
        this.loadFactor = loadFactor;
        threshold = (int)(capacity * loadFactor);
        table = new Entry[capacity];
        init();
    }
　　/**
     *根據指定容量創建一個空的HashMap
     */
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);//調用上面的構造方法，容量為指定的容量，裝載因子是默認值
    }
　　/**
     *通過傳入的map創建一個HashMap，容量為默認容量（16）和(map.zise()/DEFAULT_LOAD_FACTORY)+1的較大者，裝載因子為默認值
     */
    public HashMap(Map<? extends K, ? extends V> m) {
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
        putAllForCreate(m);
    }

　　這里需要注意一個小問題，在第二個構造方法中，capacity才是初始容量，而不是initialCapacity，即如果執行new HashMap(9,0.75),那么HashMap的初始容量是16，而不是9。

　　在初始化table的時候都使用了Entry,這是HashMap的一個內部類。

　　Map.Entry接口定義的方法

K getKey();
V getValue();
V setValue();
boolean equals(Object o);
int hashCode();

　　HashMap.Entry類的具體實現

static class Entry<K,V> implements Map.Entry<K,V> {
         final K key;
         V value;
         Entry<K,V> next;//對下一個節點的引用
         final int hash;
 
         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;//返回的是之前的Value
         }
 
         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();
 　　　　　　　// Key相等且Value相等則兩個Entry相等
             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方法，是輸出更清晰
         public final String toString() {
             return getKey() + "=" + getValue();
         }
 
         void recordAccess(HashMap<K,V> m) {
         }
 
         void recordRemoval(HashMap<K,V> m) {
         }
     }

　　put()

public V put(K key, V value) {
         if (key == null)
             return putForNullKey(value);
         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;
             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;
     }

　　當待put的key為null的時候會調用putForNullKey(value)方法,暫且繞過，先來看看如何hash。HashMap並不是直接將對象的hashcode作為哈希值，而是把key的hashcode做一些運算以得到最終的哈希值，而且得到的哈希值也不是在數組中的位置，無論是get還是put還是別的方法，計算哈希值都是：

int hash = hash(key.hashCode());

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方法為什么要這樣取值，有待探討，但是作用肯定是防止沖突。如何確定數據在數組中的位置：

int hash = hash(k.hashCode());
int i = indexFor(hash,table.length);

　　第一行，得到哈希值，第二行，根據哈希值計算元素在數組中的位置。

static int indexFor(int h,int length){
       return h & (length - 1);  
}

　　"h&(length-1)"其實這里有點小巧妙，為什么是做與運算？

　　首先我們要確定，HashMap的數組長度永遠是偶數，所以length-1一定是一個奇數，假設現在的長度是16，length-1就是15，對應的二進制是：1111。

　　假設有兩個元素，一個哈希值是8，二進制是1000，一個哈希值是9，二進制是1001。和1111與運算后，分別還是1000和1001，他們被分配在了數組的不同位置，這樣，哈希的分布非常均勻。

　　那么如果數組的長度是奇數，減去1后就是偶數了，偶數對應的二進制最低位一定是0，例如14二進制1110。對上面兩個數字分別與運算，得到1000和1000。這樣，哈希值8和9的元素會被存儲在數組同一個位置的鏈表中。在操作的時候，鏈表中的元素越多，效率就會越低，因為要不停的對鏈表循環比較。

　　在找到元素在數組中的索引位置以后，會循環遍歷table[i]所在的鏈表，如果找到key值與傳入的key值相同的對象，則替換並返回原對象；若找不到，則通過addEntry(hash,key,value,i)添加新的對象。

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);
     if (size++ >= threshold)
     　　resize(2 * table.length);
    }

　　以上過程就是新建一個Entry對象，並放在當前位置的Entry鏈表的頭部。然后判斷size是否達到了需要擴容的界限並讓size增加1，如果達到了擴容的界限則調用resize(int capacity)方法。

void resize(int newCapacity) {
         Entry[] oldTable = table;
         int oldCapacity = oldTable.length;
         // 這個if塊表明，如果容量已經到達允許的最大值，即MAXIMUN_CAPACITY，則不再拓展容量，而將裝載拓展的界限值設為計算機允許的最大值。
         // 不會再觸發resize方法，而是不斷的向map中添加內容，即table數組中的鏈表可以不斷變長，但數組長度不再改變
         if (oldCapacity == MAXIMUM_CAPACITY) {
             threshold = Integer.MAX_VALUE;
             return;
         }
         // 創建新數組，容量為指定的容量
         Entry[] newTable = new Entry[newCapacity];
         transfer(newTable);
         table = newTable;
         // 設置下一次需要調整數組大小的界限
         threshold = (int)(newCapacity * loadFactor);
     }

　　這里需要重點看看transfer方法：

void transfer(Entry[] newTable) {
         // 保留原數組的引用到src中，
         Entry[] src = table;
         // 新容量使新數組的長度
         int newCapacity = newTable.length;
 　　　　　// 遍歷原數組
         for (int j = 0; j < src.length; j++) {
             // 獲取元素e
             Entry<K,V> e = src[j];
             if (e != null) {
                 // 將原數組中的元素置為null
                 src[j] = null;
                 // 遍歷原數組中j位置指向的鏈表
                 do {
                     Entry<K,V> next = e.next;
                     // 根據新的容量計算e在新數組中的位置
                     int i = indexFor(e.hash, newCapacity);
                     // 將e插入到newTable[i]指向的鏈表的頭部
                     e.next = newTable[i];
                     newTable[i] = e;
                     e = next;
                 } while (e != null);
             }
         }
     }

　　tranfer方法將所有的元素重新哈希，因為新的容量變大，所以每個元素的哈希值和位置都是不一樣的。

　　如果key值為空，我們來看看putForNullKey的處理過程：

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;
     }

　　這是一個私有方法，在put方法中被調用。它首先遍歷table數組，如果找到key為null的元素，則替換值並返回oldValue；否則通過addEntry方法添加元素，並返回null。

　　正確的使用HashMap

　　1.不要再並發場景中使用HashMap

　　　HashMap是線程不安全的，如果被多個線程共享的操作，將會引發不可預知的問題。據sun的說法，在擴容時，會引起鏈表的閉環，在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;
    }

　　2.如果數據大小是固定的，那么最好給HashMap設定一個合理的容量值。

　　本文大量參考借鑒杭州.Mark童鞋HashMap源碼分析這篇文章，如有冒犯，還請見諒。