HashTable是jdk 1.0中引入的産物，基本上現在很少使用了，但是會在面試中經常被問到，你都知道嗎：
和HashMap一樣，Hashtable也是一個散列表，它存儲的内容是鍵值對(key-value)映射, 重要特點如下:
以上是Hashtable的類結構圖：
使用案例：
@Test
public void test() {
Hashtable<String, String> table=new Hashtable<>();
Hashtable<String, String> table1=new Hashtable<>(16);
Hashtable<String, String> table2=new Hashtable<>(16, 0.75f);
table.put("T1", "1");
table.put("T2", "2");
System.out.println(table);
// 報空指針異常
table.put(null, "3");
}
運行結果：
和HashMap相似，Hashtable底層采用數組 鍊表的數據結構，根據key找到數組對應的桶，相同的key通過鍊表維護，當數組桶的使用到達阈值後，會進行動态擴容。但是和HashMap不同的是，鍊表不會轉換為紅黑樹。
擴容機制擴容機制依賴兩個成員變量，初始容量 和 加載因子。他們可以通過構造函數設置。
容量是值哈希表中桶的數量，初始容量就是哈希表創建時的容量。當容量達到阈值的時候，會進行擴容操作，每次擴容是原來容量的2倍加1，然後重新為hashtable中的每個元素重新分配桶的位置。
那阈值是多少呢，Hashtable的阈值，用于判斷是否需要調整Hashtable的容量，等于"Hashtable當前的容量*加載因子"。
通常，默認加載因子是 0.75, 這是在時間和空間成本上尋求一種折衷。加載因子過高雖然減少了空間開銷，但同時也增加了查找某個條目的時間。
源碼解析成員變量
// 内部采用Entry數組存儲鍵值對數據，Entry實際為單向鍊表的表頭
private transient Entry<?,?>[] table;
// HashTable裡鍵值對個數
private transient int count;
// 擴容阈值，當超過這個值時，進行擴容操作，計算方式為：數組容量*加載因子
private int threshold;
// 加載因子
private float loadFactor;
// 修改次數，用于快速失敗機制
private transient int modCount = 0;
Entry的數據結構如下：
private static class Entry<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Entry<K,V> next;
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 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)
// 容量最小為1
initialCapacity = 1;
this.loadFactor = loadFactor;
// 初始化數組
table = new Entry<?,?>[initialCapacity];
// 初始擴容阈值
threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE 1);
}
// 設置指定容量初始HashTable，加載因子為0.75
public Hashtable(int initialCapacity) {
this(initialCapacity, 0.75f);
}
// 手動指定數組初始容量為11，加載因子為0.75
public Hashtable() {
this(11, 0.75f);
}
// 方法synchronized修飾，線程安全
public synchronized V put(K key, V value) {
// 如果value為空，直接空指針
if (value == null) {
throw new NullPointerException();
}
// Makes sure the key is not already in the hashtable.
Entry<?,?> tab[] = table;
// 得到key的哈希值
int hash = key.hashCode();
// 得到該key存在到數組中的下标
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
// 得到該下标對應的Entry
Entry<K,V> entry = (Entry<K,V>)tab[index];
// 如果該下标的Entry不為null，則進行鍊表遍曆
for(; entry != null ; entry = entry.next) {
// 遍曆鍊表，如果存在key相等的節點，則替換這個節點的值，并返回舊值
if ((entry.hash == hash) && entry.key.equals(key)) {
V old = entry.value;
entry.value = value;
return old;
}
}
// 如果數組下标對應的節點為空，或者遍曆鍊表後發現沒有和該key相等的節點，則執行插入操作
addEntry(hash, key, value, index);
return null;
}
private void addEntry(int hash, K key, V value, int index) {
// 修改次數 1
modCount ;
Entry<?,?> tab[] = table;
// 判斷是否需要擴容
if (count >= threshold) {
// 如果count大于等于擴容阈值，則進行擴容
rehash();
tab = table;
// 擴容後，重新計算該key在擴容後table裡的下标
hash = key.hashCode();
index = (hash & 0x7FFFFFFF) % tab.length;
}
// Creates the new entry.
@SuppressWarnings("unchecked")
// 采用頭插的方式插入，index位置的節點為新節點的next節點
// 新節點取代inde位置節點
Entry<K,V> e = (Entry<K,V>) tab[index];
tab[index] = new Entry<>(hash, key, value, e);
// count 1
count ;
}
擴容rehash源碼如下：
protected void rehash() {
// 暫存舊的table和容量
int oldCapacity = table.length;
Entry<?,?>[] oldMap = table;
// 新容量為舊容量的2n 1倍
int newCapacity = (oldCapacity << 1) 1;
// 判斷新容量是否超過最大容量
if (newCapacity - MAX_ARRAY_SIZE > 0) {
// 如果舊容量已經是最大容量大話，就不擴容了
if (oldCapacity == MAX_ARRAY_SIZE)
// Keep running with MAX_ARRAY_SIZE buckets
return;
// 新容量最大值隻能是MAX_ARRAY_SIZE
newCapacity = MAX_ARRAY_SIZE;
}
// 用新容量創建一個新Entry數組
Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];
// 模數 1
modCount ;
// 重新計算下次擴容阈值
threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE 1);
// 将新Entry數組賦值給table
table = newMap;
// 遍曆數組和鍊表，進行新table賦值操作
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;
}
}
}
public synchronized V get(Object key) {
Entry<?,?> tab[] = table;
int hash = key.hashCode();
// 根據key哈希得到index，遍曆鍊表取值
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;
}
public synchronized V remove(Object key) {
Entry<?,?> tab[] = table;
int hash = key.hashCode();
// 獲取key對應的index
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
// 遍曆鍊表，如果找到key相等的節點，則改變前繼和後繼節點的關系，并删除相應引用，讓GC回收
Entry<K,V> e = (Entry<K,V>)tab[index];
for(Entry<K,V> prev = null ; e != null ; prev = e, e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
modCount ;
if (prev != null) {
prev.next = e.next;
} else {
tab[index] = e.next;
}
count--;
V oldValue = e.value;
e.value = null;
return oldValue;
}
}
return null;
}
本文主要講解了Hashtable的基本功能和源碼解析，雖然Hashtable本身不常用了，但是它的直接子類Properties目前還在被大量使用當中，所以學習它還是有一定價值的。下面在總結下Hashtable和HashMap的區别：
更多精彩资讯请关注tft每日頭條，我们将持续为您更新最新资讯!
zpostcode 
Recruit 
weather 
mreligion 
Yellowpages 
sport 
constellation 
shopping 
name 
game 
directory 
literature 
Word 
tour 
furnish 
Lottery 
tftnews 
lyrics 
News 
digital 
car 
dir 
Edu 
Finance 
