原始碼分析——HashMap

int threshold;             // 所能容納的key-value對極限 
final float loadFactor;    // 負載因子
int modCount;  
int size;複製程式碼

• 新建一個 HashMap，預設大小為 16；
• 插入 <K1,V1> 鍵值對，先計算 K1 的 hashCode 為 115，使用除留餘數法得到所在的桶下標 115%16=3。
• 插入 <K2,V2> 鍵值對，先計算 K2 的 hashCode 為 118，使用除留餘數法得到所在的桶下標 118%16=6。
• 插入 <K3,V3> 鍵值對，先計算 K3 的 hashCode 為 118，使用除留餘數法得到所在的桶下標 118%16=6，插在 <K2,V2> 前面。

• 計算鍵值對所在的桶；
• 在連結串列上順序查詢，時間複雜度顯然和連結串列的長度成正比。

x   : 00010000
x-1 : 00001111
複製程式碼

y       : 10110010
x-1     : 00001111
y&(x-1) : 00000010複製程式碼

y   : 10110010
x   : 00010000
y%x : 00000010複製程式碼

public V put(K key, V value) {
      // 對key的hashCode()做hash
      return putVal(hash(key), key, value, false, true);
  }
  
  final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                 boolean evict) {
      Node<K,V>[] tab; Node<K,V> p; int n, i;
      // 步驟1：tab為空則建立
     if ((tab = table) == null || (n = tab.length) == 0)
         n = (tab = resize()).length;
     // 步驟2：計算index，並對null做處理 
     if ((p = tab[i = (n - 1) & hash]) == null) 
         tab[i] = newNode(hash, key, value, null);
     else {
         Node<K,V> e; K k;
         // 步驟3：節點key存在，直接覆蓋value
         if (p.hash == hash &&
             ((k = p.key) == key || (key != null && key.equals(k))))
             e = p;
         // 步驟4：判斷該鏈為紅黑樹
         else if (p instanceof TreeNode)
             e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
         // 步驟5：該鏈為連結串列
         else {
             for (int binCount = 0; ; ++binCount) {
                 if ((e = p.next) == null) {
                     p.next = newNode(hash, key,value,null);
                      //連結串列長度大於8轉換為紅黑樹進行處理
                     if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st  
                         treeifyBin(tab, hash);
                     break;
                 }
                    // key已經存在直接覆蓋value
                 if (e.hash == hash &&
                     ((k = e.key) == key || (key != null && key.equals(k)))) 
							break;
                 p = e;
             }
         }
         
         if (e != null) { // existing mapping for key
             V oldValue = e.value;
             if (!onlyIfAbsent || oldValue == null)
                 e.value = value;
             afterNodeAccess(e);
             return oldValue;
         }
     }

     ++modCount;
     // 步驟6：超過最大容量 就擴容
     if (++size > threshold)
         resize();
     afterNodeInsertion(evict);
     return null;
 }複製程式碼

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;
}複製程式碼

void addEntry(int hash, K key, V value, int bucketIndex) {
    if ((size >= threshold) && (null != table[bucketIndex])) {
        resize(2 * table.length);
        hash = (null != key) ? hash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }

    createEntry(hash, key, value, bucketIndex);
}

void createEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
    // 頭插法，連結串列頭部指向新的鍵值對
    table[bucketIndex] = new Entry<>(hash, key, value, e);
    size++;
}

Entry(int h, K k, V v, Entry<K,V> n) {
    value = v;
    next = n;
    key = k;
    hash = h;
}
複製程式碼

2.3. 擴容-基本原理

和擴容相關的引數主要有：capacity、size、threshold 和 load_factor。

void addEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<>(hash, key, value, e);
    if (size++ >= threshold)
        resize(2 * table.length);
}複製程式碼

void resize(int newCapacity) {   //傳入新的容量
     Entry[] oldTable = table;    //引用擴容前的Entry陣列
     int oldCapacity = oldTable.length;         
     if (oldCapacity == MAXIMUM_CAPACITY) {  //擴容前的陣列大小如果已經達到最大(2^30)了
         threshold = Integer.MAX_VALUE; //修改閾值為int的最大值(2^31-1)，這樣以後就不會擴容了
         return;
     }
  
     Entry[] newTable = new Entry[newCapacity];  //初始化一個新的Entry陣列
    transfer(newTable);                         //將資料轉移到新的Entry陣列裡
    table = newTable;                           //HashMap的table屬性引用新的Entry陣列
    threshold = (int)(newCapacity * loadFactor);//修改閾值
}
複製程式碼

• hashmap不是執行緒安全的、hashtable是安全的
• HashMap允許將 null 作為一個 entry 的 key 或者 value，而 Hashtable 不允許。
• HashMap 把 Hashtable 的 contains 方法去掉了，改成 containsValue 和 containsKey。因為 contains 方法容易讓人引起誤解。
• HashTable 繼承自 Dictionary 類，而 HashMap 是 Java1.2 引進的 Map interface 的一個實現。
• HashTable 的方法是 Synchronized 的，而 HashMap 不是，在多個執行緒訪問 Hashtable 時，不需要自己為它的方法實現同步，而 HashMap 就必須為之提供外同步，或者改為使用ConcurrentHashMap。
  
• Hashtable 和 HashMap 採用的 hash/rehash 演算法都大概一樣，所以效能不會有很大的差異。
• HashMap 不能保證隨著時間的推移 Map 中的元素次序是不變的。
• HashMap 的迭代器是 fail-fast 迭代器。

1. 擴容是一個特別耗效能的操作，所以當程式設計師在使用HashMap的時候，估算map的大小，初始化的時候給一個大致的數值，避免map進行頻繁的擴容。
2. 負載因子是可以修改的，也可以大於1，但是建議不要輕易修改。
3. HashMap是執行緒不安全的，不要在併發的環境中同時操作HashMap，建議使用ConcurrentHashMap。
4. JDK1.8引入紅黑樹很大程度優化了HashMap的效能。

閱讀原始碼是一件十分耗費精力的事情，但從中你可以領悟到JDK作者的巧妙思路，在原始碼層面去理解為什麼HashMap是執行緒不安全的，HashMap的擴容機制等等，而不是僅僅停留在會用HashMap這個容器的表面理解上。