（二）Java集合專題-詳細分析HashtableJDK1.8集合底層實現的思想
阿新 • • 發佈：2018-11-05
（一）詳細分析Hashtable1.8集合底層實現的思路和原始碼
（1）先來看一下Hashtable的結構圖：首先他和HashMap結構都是一樣的，都是由陣列和連結串列進行實現的（在JDK1.8是用陣列和連結串列和紅黑樹的），每一個數組裡面存的是一個Entry節點，節點裡面有Key、Value，唯一最大 的區別就是HashMap實現不是執行緒安全的，但是Hashtable是執行緒安全的，但是Hashtable在多執行緒下的效率不是很好，比起ConcurrentHashMap的效率比起來還是有點低的。所以不建議使用，這裡只做瞭解就行了
Hashtable繼承的是Dictionary，實現的是Map的介面、Cloneable、和Serializable 的序列化介面
- public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, java.io.Serializable {
（2）他的主要方法都是通過Synchronize來實現的：
public synchronized int size(){} public synchronized boolean isEmpty() {} public synchronized Enumeration<K> keys() {} public synchronized Enumeration<V> elements() {} public synchronized boolean contains(Object value) {} public synchronized boolean containsKey(Object key) {} public synchronized V get(Object key) {} public synchronized V put(K key, V value) {} public synchronized V remove(Object key) {} public synchronized void putAll(Map<? extends K, ? extends V> t) {} public synchronized void clear() {} public synchronized Object clone() {} public synchronized String toString() {} public synchronized boolean equals(Object o) {} public synchronized int hashCode() {}
（3）看一下幾個主要的原始碼的實現和初始化的原始碼：
-
- Hashtable的一些變數引數：
public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable { // 儲存元素的table，Entry節點採用內部類實現 private transient Entry[] table; // 已存放元素的計數器 private transient int count; // 擴容閾值=table長度 * loadFactor // table表的元素（不包含連結串列中的元素）超過這個閾值將擴容 private int threshold; // 負載因子 private float loadFactor; // 其他省略 }
-
- Hashtable的初始化：在預設構造方法中，呼叫了Hashtable(int initialCapacity, float loadFactor)方法，初始Hashtable的容量為11，負載因子為0.75，那麼初始閾值就是8。這點和HashMap很不同，HashMap在初始化時，table的大小總是2的冪次方，即使給定一個不是2的冪次方容量的值，也會自動初始化為最接近其2的冪次方的容量
public Hashtable(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal Load: "+loadFactor);
if (initialCapacity==0)
initialCapacity = 1;
this.loadFactor = loadFactor;
table = new Entry<?,?>[initialCapacity];
threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
}
-
- 內部類Entry節點：Entry節點中儲存了元素的hash值，next是指連結串列的下一個節點
private static class Entry<K,V> implements Map.Entry<K,V> {
int hash;
K key;
V value;
Entry<K,V> next;// 連結的下一個節點，構成連結串列
}
-
- get（）方法的原始碼實現：
public synchronized V get(Object key) {
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
return (V)e.value;
}
}
return null;
}
- 第一步先對Hashtable的key進行拿到hashcode,
- 然後用key的hashcode值進行疑惑，然後對陣列的長度進行取餘，這裡效率沒有HashMap的效率高
- 然後再去判斷當前的這個Entry節點有沒有存在資料值，3.1 如果存在，就去判斷這個Entry節點的key是不是和等於你要取的值對應的按個key，若果是直接返回
- 如果剛剛的那個3.1哪一步判斷不存在，就說明沒有你要的值，就直接返回NULL
- 然後是Hashtable的put方法的實現：
public synchronized V put(K key, V value) {
// Make sure the value is not null
if (value == null) {
throw new NullPointerException();
}
// Makes sure the key is not already in the hashtable.
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
Entry<K,V> entry = (Entry<K,V>)tab[index];
for(; entry != null ; entry = entry.next) {
if ((entry.hash == hash) && entry.key.equals(key)) {
V old = entry.value;
entry.value = value;
return old;
}
}
addEntry(hash, key, value, index);
return null;
}
這個是Put方法中的addEntry（）方法
private void addEntry(int hash, K key, V value, int index) {
modCount++;
Entry<?,?> tab[] = table;
if (count >= threshold) {
// Rehash the table if the threshold is exceeded
rehash();
tab = table;
hash = key.hashCode();
index = (hash & 0x7FFFFFFF) % tab.length;
}
// Creates the new entry.
@SuppressWarnings("unchecked")
Entry<K,V> e = (Entry<K,V>) tab[index];
tab[index] = new Entry<>(hash, key, value, e);
count++;
}
這個是addEntry()方法中的rehash（）方法
protected void rehash() {
int oldCapacity = table.length;
Entry<?,?>[] oldMap = table;
// overflow-conscious code
int newCapacity = (oldCapacity << 1) + 1;
if (newCapacity - MAX_ARRAY_SIZE > 0) {
if (oldCapacity == MAX_ARRAY_SIZE)
// Keep running with MAX_ARRAY_SIZE buckets
return;
newCapacity = MAX_ARRAY_SIZE;
}
Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];
modCount++;
threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
table = newMap;
for (int i = oldCapacity ; i-- > 0 ;) {
for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
Entry<K,V> e = old;
old = old.next;
int index = (e.hash & 0x7FFFFFFF) % newCapacity;
e.next = (Entry<K,V>)newMap[index];
newMap[index] = e;
}
}
}
這裡重點說一下Hashtable中的put（）方法的思路；
1、禁止null value插入。
2、根據key的hashCode值 與 0x7FFFFFFF求與後得到新的hash值，然後計算其在table中的索引下標。
3、在索引下標下遍歷連結串列，查詢key是否已存在，存在則更新value值。
4、如果不存在，判斷table.count是否超過閾值，超過則重新rehash，將原元素全部拷貝到新的table中，並重新計算索引下標。rehash後，容量是以前的2倍+1的大小，這點也和HashMap不同，HashMap是2倍。
5、插入元素時直接插入在連結串列頭部。
6、更新元素計數器。
最後終結一下HashMap和Hashtable的不同之處？
- 首先第一點是HashMap不是執行緒安全的，但是Hashtable是執行緒安全的
- HashMap的key和value都可以為NULL，但是Hashtable的key和value都不能為NULL，否則直接報錯。
- 在HashMap中的put（）方法中，在定位桶陣列的下標的時候，使用的是key的hashcode &(n - 1) 跟通陣列的長度進行與的位運算，但是在Hashtable中的時候，用到的是(hash & 0x7FFFFFFF) % tab.length;這是對桶陣列的長度進行取模，效率肯定沒有上一步的hashmap的效率高
- HashMap的初始化預設桶陣列的長度是16負載因子0.75，但是在Hashtable中的通陣列的預設長度是11負載因子是0.75，在進行擴容的時候也會有點不一樣，在Hashtable中的擴容時用的是(oldCapacity << 1) + 1（也就是把原來的桶陣列長度左移一位二進位制，也就是長度*2+1）來進行的，而在HashMap中是直接二倍進行擴容的。
- 另一個區別是HashMap的迭代器(Iterator)是fail-fast迭代器，而Hashtable的enumerator迭代器不是fail-fast的。所以當有其它執行緒改變了HashMap的結構（增加或者移除元素），將會丟擲ConcurrentModificationException，但迭代器本身的remove()方法移除元素則不會丟擲ConcurrentModificationException異常。但這並不是一個一定發生的行為，要看JVM。這條同樣也是Enumeration和Iterator的區別。