HashTable作为集合框架中的一员，现在是很少使用了，一般都是在面试中会问到其与HashMap的区别。为了能在求职的时候用上场，我们有必要对其原理进行解读。
HashTable的实现原理跟HashMap类似，也是通过节点的哈希值映射到哈希桶数组，如果发生哈希碰撞就构建一条链表，简单点说就是：数组+链表
一、类的定义
public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, java.io.Serializable {}从以上的定义中，可以发现其继承自Dictionary，而HashMap是继承自AbstractMap。Dictionary是一个字典类，内部定义了一些抽象方法，现在官方也不建议使用了。我的理解也是用来保存key-value的，不过要求key和value都不能为空。
二、存储单元
基本存储单元：
private static class Entry<K,V> implements Map.Entry<K,V> {
final int hash; // key算出的哈希值
final K key;
V value;
Entry<K,V> next; // 如果有链表的话指向下一个节点
}哈希桶数组：
private transient Entry<?,?>[] table;三、构造函数
HashTable有四个构造函数，可以按照需要进行选择。一般情况下，如果知道节点数量，可以在初始化的时候指定哈希桶的容量。
// 无参构造器
public Hashtable() {
this(11, 0.75f); // 默认哈希桶初始容量为11，负载因子为0.75
}// 自定义初始哈希桶容量构造器
public Hashtable(int initialCapacity) {
this(initialCapacity, 0.75f);
}// 自定义容量和负载因子构造器，负载因子一般情况下使用0.75
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];
// 初始化扩容阈值，节点超过这个值会进行扩容，其中MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
}// 可以在构造器中传入Map，其全部元素会put到新构建的HashTable中
public Hashtable(Map<? extends K, ? extends V> t) {
this(Math.max(2*t.size(), 11), 0.75f);
putAll(t);
}四、存储实现
HashTable的put、get方法都使用了同步加锁，所以他们是线程安全的。
1.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;
// key直接获取哈希值，因此key不能为空，否则会抛空指针异常
int hash = key.hashCode();
// 计算在哈希桶的位置
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
Entry<K,V> entry = (Entry<K,V>)tab[index];
// 判断index位置是否为空，不为空判断hash和key是否相等，相等的话覆盖原有的value
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;
}// 添加新节点到哈希桶
private void addEntry(int hash, K key, V value, int index) {
// 修改数加一，fast-fail机制
modCount++;
Entry<?,?> tab[] = table;
// 判断是否需要扩容，节点总数等于等于阈值就会扩容，阈值一般等于容量乘以0.75
if (count >= threshold) {
// Rehash the table if the threshold is exceeded
rehash();
tab = table;
hash = key.hashCode();
// 计算index位置
index = (hash & 0x7FFFFFFF) % tab.length;
}
// 创建新的节点，并放到哈希桶中，如果有链表则是链表的头部
@SuppressWarnings("unchecked")
Entry<K,V> e = (Entry<K,V>) tab[index];
tab[index] = new Entry<>(hash, key, value, e);
// 节点总数加一
count++;
} 2.get方法
// 同步加锁
public synchronized V get(Object key) {
Entry<?,?> tab[] = table;
int hash = key.hashCode();
// 根据hash值计算在哈希桶的位置
int index = (hash & 0x7FFFFFFF) % tab.length;
// 如果哈希桶的位置上是链表，则遍历链表找到hash值和key都相等的对象
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的扩容是把原来的容量扩大为2倍加一，并把旧哈希桶的节点重新计算哈希映射到新的哈希桶
protected void rehash() {
int oldCapacity = table.length;
Entry<?,?>[] oldMap = table;
// 新容量等于旧容量的两倍加1，不太清楚为什么要加一，我估计是为了平均节点到哈希桶，减少哈希碰撞
int newCapacity = (oldCapacity << 1) + 1;
if (newCapacity - MAX_ARRAY_SIZE > 0) {
// 如果就容量已经达到最大值就不在扩容了，MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
if (oldCapacity == MAX_ARRAY_SIZE)
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的遍历操作也是线程安全的，通过调用Collections.synchronizedSet()的方法，给遍历操作加了一个包装器。里面对key、value或者key-value的遍历实现还是挺有借鉴意思的，它用泛型只要写一次代码就可以实现三种遍历方式。
// 该方法返回一个Set，其实遍历只需要迭代器，entrySet返回的Set对象实现了迭代器
public Set<Map.Entry<K,V>> entrySet() {
if (entrySet==null)
// 返回线程安全的集合类，这里是通过线程安全的方法对目标方法做了一层包装
entrySet = Collections.synchronizedSet(new EntrySet(), this);
return entrySet;
}简单看看EntrySet的实现
// 只看迭代器部分
private class EntrySet extends AbstractSet<Map.Entry<K,V>> {
public Iterator<Map.Entry<K,V>> iterator() {
return getIterator(ENTRIES);
}
}private <T> Iterator<T> getIterator(int type) {
// 判断节点数是否为0
if (count == 0) {
return Collections.emptyIterator();
} else {
return new Enumerator<>(type, true);
}
}// HashTable的内部类，可以共用外部类的属性和方法
private class Enumerator<T> implements Enumeration<T>, Iterator<T> {
Entry<?,?>[] table = Hashtable.this.table;
int index = table.length;
Entry<?,?> entry = null;
Entry<?,?> lastReturned = null;
int type;
boolean iterator;
protected int expectedModCount = modCount;
Enumerator(int type, boolean iterator) {
this.type = type;
this.iterator = iterator;
}
public boolean hasMoreElements() {
Entry<?,?> e = entry;
int i = index;
Entry<?,?>[] t = table;
// 从哈希桶的最后遍历节点
while (e == null && i > 0) {
e = t[--i];
}
entry = e;
index = i;
return e != null;
}
@SuppressWarnings("unchecked")
public T nextElement() {
Entry<?,?> et = entry;
int i = index;
Entry<?,?>[] t = table;
// 如果当前节点为空，表示index位置的节点遍历完了，则继续遍历哈希桶
while (et == null && i > 0) {
et = t[--i];
}
entry = et;
index = i;
if (et != null) {
Entry<?,?> e = lastReturned = entry;
entry = e.next;
// 这里使用了泛型可以返回key，value或者key-value对象
return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e);
}
throw new NoSuchElementException("Hashtable Enumerator");
}
// 迭代器方法
public boolean hasNext() {
return hasMoreElements();
}
// 迭代器方法
public T next() {
// fast-fail机制
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
return nextElement();
}
// 迭代器方法，删除节点
public void remove() {
if (!iterator)
throw new UnsupportedOperationException();
if (lastReturned == null)
throw new IllegalStateException("Hashtable Enumerator");
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
synchronized(Hashtable.this) {
Entry<?,?>[] tab = Hashtable.this.table;
int index = (lastReturned.hash & 0x7FFFFFFF) % tab.length;
// 找出当前要删除的节点在哈希桶的位置
@SuppressWarnings("unchecked")
Entry<K,V> e = (Entry<K,V>)tab[index];
// 遍历index位置的链表
for(Entry<K,V> prev = null; e != null; prev = e, e = e.next) {
// 找出当前遍历的节点
if (e == lastReturned) {
modCount++;
expectedModCount++;
// 判断是否在链表的头部
if (prev == null)
tab[index] = e.next;
else
prev.next = e.next;
count--;
lastReturned = null;
return;
}
}
throw new ConcurrentModificationException();
}
}
}七、总结
HashTable的数据结构跟HashMap类似，下面总结一下他们的区别：
- key-value是否可以为空。HashTable的key和value都不可以为空，为空会报空指针异常。HashMap的key，value都可以为空，但是key只能有一个为null，value都可以为空。
- 是否线程安全。HashTable操作节点的方法都是同步加锁的，所以是线程安全的。HashMap不是线程安全的。
- 类继承关系是否一样。HashTable继承Dictionary。HashMap继承AbstractMap。
- 初始容量。HashTable初始容量为11。HashMap初始容量为16。
- 最大容量（哈希桶的容量，不是存储元素的容量）。HashTable最大为Integer.MAX_VALUE - 8=2147483639。HashMap最大为1<<30=1073741824。
以上就是我对HashTable的解读，如果有错误之处，欢迎批评和指正。