Hashtable /HashMap / LinkedHashMap 概述
* Hashtable比較早，是線程安全的哈希映射表。內部采用Entry[]數組，每個Entry均可作為鏈表的頭，用來解決沖突（碰撞）。
* HashMap與Hashtable基本原理一樣，只是HashMap允許null的key/value，且非線程安全。
* LinkedHashMap從字面看有兩個意思，Hash和Linked，既通過Hash散列存儲（與HashMap相同），又把每個Entry（增加了before/after指針）通過雙向鏈表進行連接，記錄元素插入的順序。根據Key取數據，可按照HashMap的散列迅速定位Value；迭代時，可按照雙向鏈表，高效遍歷。
Hashtable 特點
* 線程安全。
* Key、Value均不能為null。
* 包含了一個Entry[]數組，而Entry又是一個鏈表，用來處理沖突。
* 每個Key對應了Entry數組中固定的位置（記為index），稱為槽位（Slot）。槽位計算公式為： (key.hashCode() & 0x7FFFFFFF) % Entry[].length() 。
* 當Entry[]的實際元素數量（Count）超過了分配容量（Capacity）的75%時，新建一個Entry[]是原先的2倍，並重新Hash（rehash）。
* rehash的核心思路是，將舊Entry[]數組的元素重新計算槽位，散列到新Entry[]中。
Hashtable 源碼簡要分析
Entry類
class Entry<K,V> // Entry<K,V>是槽中的元素，可做鏈表，解決散列沖突。
{
int hash; // 即key.hashCode()
K key;
V value;
Entry<K,V> next; // 用來實現鏈表結構。同一鏈表中的key的hash是相同的。
protected Entry(int hash, K key, V value, Entry<K,V> next) {
this.hash=hash;this.key=key;this.value=value;this.next=next;
}
}
Hashtable類
public class Hashtable<K,V>
{
Entry[] table; // 槽數組，也稱桶數組。
int count; // table中實際存放的Entry數量。
int threshold; // 當table數量超過該閾值后，進行reash。（該值為 capacity * loadFactor）
float loadFactor; // 加載因子，默認是0.75f。
public Hashtable(int initialCapacity/*默認是11*/, float loadFactor) {
if(initialCapacity==0) initialCapacity=1;
this.locadFactor = locadFactor;
table = new Entry[initialCapacity];
threshold = (int)(initialCapacity * locadFactor);
}
// put()： 若key存在，返回舊value；若key不存在，返回null。
public synchronized V put(K key,V value) {
// 檢查key是否已經存在，若存在則覆蓋已經存在value，並返回被覆蓋的value。
Entry tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length; // 存儲槽位索引。
for(Entry<K,V> e = tab[index]; e!=null; e=e.next ) { // 在沖突鏈表中尋找
if( (e.hash == hash ) && e.key.equals(key) ) {
V old = e.value;
e.value = value; // 新value覆蓋舊value
return old;
}
}
// 是否需要rehash
if(count >= threshold){
rehash();
tab = table; // rehash完畢后，修正tab指針指向新的Entry[]
index = (hash & 0x7FFFFFFF) % tab.length; // 重新計算Slot的index
}
// 存儲到槽位，如果有沖突，新來的元素被放到了鏈表前面。
Entry<K,V> e = tab[index]; // 舊有Entry
tab[index] = new Entry<>(hash,key,value,e/* 舊有Entry成為了新增Entry的next */);
count ++;
return null;
}
// rehash(): 再次hash。當Entry[]的實際存儲數量占分配容量的約75%時，擴容並且重新計算各個對象的槽位
static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8 ;
protected void rehash() {
int oldCapacity = table.length;
Entry[] oldMap = table;
int newCapacity = (oldCapacity << 1) + 1; // 2倍+1
Entry[] newMap = new Entry[newCapacity];
threshold = (int)(newCapacity * loadFactor);
table = newMap;
for( int i=oldCapacity; i-- >0;){ // i的取值范圍為 [oldCapacity-1,0]
for (Entry<K,V> old = oldMap[i]; old!=null;){ // 遍歷舊Entry[]
Entry<K,V> e = old;
int index = (e.hash & 0x7FFFFFFF) % newCapacity; // 重新計算各個元素在新Entry[]中的槽位index。
e.next = newMap[index]; // 已經存在槽位中的Entry放到當前元素的next中
newMap[index]=e; // 放到槽位中
old = old.next;
}
}
}
}
References
JDK源碼