简介
Hashtable和HashM类似，同样是基于哈希表实现的，同样每个元素是一个key-value对，但其内部只是通过单链表解决哈希冲突问题，而没有红黑树结构，当HashTable容量不足（超过了阀值）时，同样会进行扩容操作。Hashtable类声明如下：
public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable
它继承于Dictionary，实现了Map、Cloneable、 Serializable等接口。
Hashtable实现了Map接口，可以对它进行哈希表操作；实现了Cloneable接口，能被克隆；实现了Serializable接口，因此它支持序列化，能够通过序列化传输。
Hashtable是JDK1.0引入的类，Hashtable的很多方法都用synchronized修饰，是线程安全的，可以用于多线程环境中。
Hashtable源码详解
HashTable有如下几个成员变量：
// 存储链表的数组 private transient Entry<?,?>[] table; // 键值对的个数 private transient int count; // 下一次resize的阈值大小 = HashTable容量 * 负载因子 private int threshold; // 负载因子 private float loadFactor; // HashTable结构修改次数，用于fail-fast机制 private transient int modCount = 0;
HashTable中的节点都被封装成为了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;
}
@SuppressWarnings("unchecked")
protected Object clone() {
return new Entry<>(hash, key, value,
(next==null ? null : (Entry<K,V>) next.clone()));
}
// Map.Entry Ops
public K getKey() {
return key;
}
public V getValue() {
return value;
}
// 设置value，若value是null，则抛出NullPointerException异常
public V setValue(V value) {
if (value == null)
throw new NullPointerException();
V oldValue = this.value;
this.value = value;
return oldValue;
}
public boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
return (key==null ? e.getKey()==null : key.equals(e.getKey())) &&
(value==null ? e.getValue()==null : value.equals(e.getValue()));
}
public int hashCode() {
return hash ^ Objects.hashCode(value);
}
public String toString() {
return key.toString()+"="+value.toString();
}
}
HashTable有如下四个构造方法：
// 参数指定了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)
initialCapacity = 1;
this.loadFactor = loadFactor;
table = new Entry<?,?>[initialCapacity];
threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
}
// 参数指定了HashMap初始化时的容量，负载因子默认为0.75
public Hashtable(int initialCapacity) {
this(initialCapacity, 0.75f);
}
// 无参构造方法，默认的初始化容量为11，负载因子默认为的0.75
public Hashtable() {
this(11, 0.75f);
}
// 根据其他Map来创建HashTable，负载因子为0.75
public Hashtable(Map<? extends K, ? extends V> t) {
this(Math.max(2*t.size(), 11), 0.75f);
putAll(t);
}
我们下面来看HashTable的几个关键方法：put方法、get方法和remove方法。
put(K key, V value)方法
public synchronized V put(K key, V value) {
// 若插入元素的value为null则抛出NullPointerException异常
if (value == null) {
throw new NullPointerException();
}
// Makes sure the key is not already in the hashtable.
Entry<?,?> tab[] = table;
// 计算key的hashcode
int hash = key.hashCode();
// 计算key在table数组中的下标
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
Entry<K,V> entry = (Entry<K,V>)tab[index];
// 若数组对应下标不为null，则表明发生了哈希冲突
for(; entry != null ; entry = entry.next) {
// 若链表中已经存在键值为key的节点，则将key对应的value替换
if ((entry.hash == hash) && entry.key.equals(key)) {
V old = entry.value;
entry.value = value;
// 返回旧的value
return old;
}
}
// 将元素添加到对应下标的链表中
addEntry(hash, key, value, index);
return null;
}
从上面的源码中我们可以看出，HashTable的key和value都不可以为null，若value为null，则程序会直接抛出NullPointerException异常，若key为null，则在计算key的hashcode时，也会抛出NullPointerException异常。
若链表中没有找到键值为key的节点，则通过addEntry方法将键值对添加到HashTable中：
private void addEntry(int hash, K key, V value, int index) {
// HashTable的结构修改次数加1
modCount++;
Entry<?,?> tab[] = table;
// 若节点个数 >= 阈值，则通过rehash()方法进行扩容操作
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);
// 节点数目加1
count++;
}
若节点个数 >= 阈值，则通过rehash()方法进行扩容操作，我们来看一看rehash()方法：
扫描二维码关注公众号，回复：
1697191 查看本文章
protected void rehash() {
int oldCapacity = table.length;
Entry<?,?>[] oldMap = table;
// 计算新的容量newCapacity = (oldCapacity << 1) + 1，即新容量 = 旧容量 * 2 + 1
int newCapacity = (oldCapacity << 1) + 1;
// 若新容量大于MAX_ARRAY_SIZE，MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
if (newCapacity - MAX_ARRAY_SIZE > 0) {
// 若旧容量等于MAX_ARRAY_SIZE，则直接返回
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];
modCount++;
// 计算threshold
threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
table = newMap;
// 将旧数组的节点复制到新Entry数组中，i为数组下标
for (int i = oldCapacity ; i-- > 0 ;) {
// old为数组下标对应的链表节点
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;
}
}
}
get(Object key)方法
public synchronized V get(Object key) {
Entry<?,?> tab[] = table;
// 计算key的hashcode
int hash = key.hashCode();
// 计算key对应的数组下标
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;
}
}
// 返回null
return null;
}
remove(Object key)方法
public synchronized V remove(Object key) {
Entry<?,?> tab[] = table;
// 计算key的hashcode
int hash = key.hashCode();
// 计算key对应的数组下标
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
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的key和value都不可以为null，所以，判断一个key在HashTable中是否存在，可以用get(Object)方法的返回值是否为null来判断，同时，也可以用containsKey(Object)方法来判断，该方法与get(Object)方法很相似：
public synchronized boolean containsKey(Object key) {
Entry<?,?> tab[] = table;
// 计算key的hashcode
int hash = key.hashCode();
// 计算key对应的数组下标
int index = (hash & 0x7FFFFFFF) % tab.length;
// 遍历数组下表对应的链表
for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
// 找到匹配的节点，返回true
if ((e.hash == hash) && e.key.equals(key)) {
return true;
}
}
// 返回false
return false;
}
clear()方法
// 删除HashTable中所有的键值对
public synchronized void clear() {
Entry<?,?> tab[] = table;
modCount++;
for (int index = tab.length; --index >= 0; )
// tab[index] = null，表明JVM可以对节点的内存进行回收，同时tab也不再拥有其内存空间
tab[index] = null;
count = 0;
}
HashTable中的modCount的作用这里不再解释，可以参考这篇博客。
HashTable与HashMap的主要异同点
- 它们都是通过哈希表来实现的，而且都是通过链表来解决哈希冲突的，但是HashMap在链表达到一定长度之后，会将其转化为红黑树。
- 它们计算节点哈希值的方式不同，若key的hashcode为h，则HashMap通过h ^ (h >>> 16)来计算节点的哈希值，而HashTable则将h作为节点的哈希值。
- 它们计算节点对应数组索引下标的方式也不同，HashMap通过haseCode & (capacity - 1)是用来计算节点对应的数组下标，HashTable通过(hashCode & 0x7FFFFFFF) % capacity来计算节点对应的数组下标。hashCode & 0x7FFFFFFF的目的是为了将负的hash值转化为正值。
- HashTable的默认容量为11，而HashMap默认容量为16，Hashtable不要求底层数组的容量一定要为2的整数次幂，而HashMap则要求一定为2的整数次幂。但是，它们的默认负载因子都是0.75。
- Hashtable扩容时，会将容量变为原来的2倍加1，而HashMap扩容时，会将容量变为原来的2倍。
- Hashtable中key和value都不允许为null，而HashMap中key和value都允许为null（key只能有一个为null，而value则可以有多个为null）。若Hashtable中的key或者value为null，则程序运行时会抛出NullPointerException异常。
- HashTable中的大部分的方法都被synchronized修饰，所以HashTable是线程安全的，可以用于多线程环境中，而HashMap则不行。