一、概述
Hashtable类继承于Dictionary抽象类，jdk注释中说明了Dictionary类已经过时，新的实现类应该去实现Map接口，而不是继承Dictionary类。但是面试的时候还是常常会问到Hashtable与HashMap的区别，所以我们还是来看一下Hashtable类的源码，以及现在的实际应用场景中用什么类来代替它。
二、源码分析
(1) 类的声明
-
public
class Hashtable<K,V>
-
extends
Dictionary<
K,
V>
-
implements
Map<
K,
V>,
Cloneable,
java.
io.
Serializable
与HashMap类相比，实现的接口完全一致，只是集成的父类不同：Hashtable继承了Dictionary类；HashMap则是继承自AbstractMap类。
(2) 成员变量
-
//存放Entry元素的数组
-
private
transient Entry<?,?>[] table;
-
//实际元素的数量
-
private
transient
int count;
-
//扩容的临界容量，threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
-
private
int threshold;
-
//负载因子
-
private
float loadFactor;
-
//修改标记，用于fail-fast机制
-
private
transient
int modCount =
0;
-
//指定的序列化标识ID
-
private
static
final
long serialVersionUID =
1421746759512286392L;
-
//数组最大容量，留8个字节存储对象头，具体可在jvm的学习中了解
-
private
static
final
int MAX_ARRAY_SIZE = Integer.MAX_VALUE -
8;
transient修饰符修饰的成员变量不会被序列化。
(3) 构造方法
-
//默认无参构造函数，设置默认的容量为11，负载因子为0.75f
-
public Hashtable() {
-
this(
11,
0.75f);
-
}
-
-
//指定容量的构造函数
-
public Hashtable(int initialCapacity) {
-
this(initialCapacity,
0.75f);
-
}
-
-
//指定容量和负载因子的构造函数
-
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);
-
//如果指定容量为0，那么返回的容量为1
-
if (initialCapacity==
0)
-
initialCapacity =
1;
-
this.loadFactor = loadFactor;
-
table =
new Entry<?,?>[initialCapacity];
-
threshold = (
int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE +
1);
-
}
-
//传入指定的Map返回为Hashtable
-
public Hashtable(Map<? extends K, ? extends V> t) {
-
//设置容量Math.max(2*t.size(), 11)，取2倍t的元素数量和11比较，取大的值
-
this(Math.max(
2*t.size(),
11),
0.75f);
-
putAll(t);
-
}
不同于HashMap的是，Hashtable在成员变量中并没有设置默认容量，而是在构造函数中设置的，并且默认容量为11；HashMap是成员变量中就设置了初始容量为16。
(4) Entry<K,V>源码如下：
-
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;
-
}
-
//这里与HashMap的Node不同，HashMap的Node没有clone()方法
-
@SuppressWarnings(
"unchecked")
-
protected Object clone() {
-
return
new Entry<>(hash, key, value,
-
(next==
null ?
null : (Entry<K,V>) next.clone()));
-
}
-
-
public K getKey() {
-
return key;
-
}
-
-
public V getValue() {
-
return value;
-
}
-
//设置value时，如果value为null，则直接抛出异常
-
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;
-
//必须是key和value都相等才返回true
-
return (key==
null ? e.getKey()==
null : key.equals(e.getKey())) &&
-
(value==
null ? e.getValue()==
null : value.equals(e.getValue()));
-
}
-
//hashCode()与HashMap也不同，HashMap是将key和value的hash值进行异或运算。
-
public int hashCode() {
-
return hash ^ Objects.hashCode(value);
-
}
-
-
public String toString() {
-
return key.toString()+
"="+value.toString();
-
}
-
}
(5) addEntry()方法
-
//添加一个Entry元素到指定位置index
-
private void addEntry(int hash, K key, V value, int index) {
-
//修改标记+1
-
modCount++;
-
-
Entry<?,?> tab[] = table;
-
//如果元素数量超过了限制的数量，就调用rehash()方法进行扩容
-
if (count >= threshold) {
-
// Rehash the table if the threshold is exceeded
-
rehash();
-
-
tab = table;
-
//用k的hash值与Integer.MAX_VALUE-1进行&与运算后的结果对table的容量取模获得新下标
-
hash = key.hashCode();
-
index = (hash &
0x7FFFFFFF) % tab.length;
-
}
-
-
//创建新元素，并获取旧元素e的引用
-
@SuppressWarnings(
"unchecked")
-
Entry<K,V> e = (Entry<K,V>) tab[index];
-
//将index位置设置为新元素，且新元素的下一个元素指定为e，也就是说每次添加元素都是添加在链表头
-
tab[index] =
new Entry<>(hash, key, value, e);
-
//元素总数+1
-
count++;
-
}
(6) rehash()方法
-
//扩容方法
-
protected void rehash() {
-
//记录原始的容量为oldCapacity
-
int oldCapacity = table.length;
-
//记录下原始的容器为oldMap
-
Entry<?,?>[] oldMap = table;
-
-
//计算新容量newCapacity的值为2倍oldCapacity的值+1，也就是newCapacity = 2oldCapacity + 1
-
int newCapacity = (oldCapacity <<
1) +
1;
-
//如果新容量大于数组最大运行容量MAX_ARRAY_SIZE，也就是Integer.MAX_VALUE - 8
-
if (newCapacity - MAX_ARRAY_SIZE >
0) {
-
//判断原始容量oldCapacity是否已经等于了MAX_ARRAY_SIZE，如果是则直接return
-
if (oldCapacity == MAX_ARRAY_SIZE)
-
// Keep running with MAX_ARRAY_SIZE buckets
-
return;
-
//如果原始容量oldCapacity还未达到MAX_ARRAY_SIZE，则将此次新容量newCapacity设置为MAX_ARRAY_SIZE
-
newCapacity = MAX_ARRAY_SIZE;
-
}
-
//用新容量初始化一个Entry数组
-
Entry<?,?>[] newMap =
new Entry<?,?>[newCapacity];
-
//修改标记+1
-
modCount++;
-
//计算新的扩容临界值threshold，取新容量newCapacity和负载因子loadFactor的乘积与MAX_ARRAY_SIZE + 1中较小的值
-
threshold = (
int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE +
1);
-
//将新Map设置为容器
-
table = newMap;
-
//循环将旧容器oldMap中的元素添加到新容器中
-
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;
-
//重新计算hash值
-
int index = (e.hash &
0x7FFFFFFF) % newCapacity;
-
//把newMap原来index下的元素设置为e的下一个元素，并将元素e放在index位置上
-
e.next = (Entry<K,V>)newMap[index];
-
newMap[index] = e;
-
}
-
}
-
}
HashTable的扩容机制如下：例如默认初始容量是11，加载因子为0.75，那么扩容阀值就是8，当数组长度达到8的时候，HashTable就会进行一第次扩容，扩容后的容量就是 8 * 2 + 1 = 17 ( int newCapacity = (oldCapacity << 1) + 1) ，此时的扩容阀值就是 17 * 0.75 = 13 ，当下次达到13的时候，就会在重复扩容一次。其实，这个扩容消耗还是蛮大的，因为扩容后需要原来HashTable中的元素一一复制到新的HashTable中。
(7) put()方法
-
//添加一个元素
-
public synchronized V put(K key, V value) {
-
// 如果value为null，直接抛出异常
-
if (value ==
null) {
-
throw
new NullPointerException();
-
}
-
//获取现有的容器tab[]
-
Entry<?,?> tab[] = table;
-
//计算桶位,如果key为null,此处会抛异常
-
int hash = key.hashCode();
-
int index = (hash &
0x7FFFFFFF) % tab.length;
-
@SuppressWarnings(
"unchecked")
-
Entry<K,V> entry = (Entry<K,V>)tab[index];
-
//循环遍历是否有相同key的元素存在，如果有就替换旧元素的value值，并且返回旧元素的alue值
-
for(; entry !=
null ; entry = entry.next) {
-
if ((entry.hash == hash) && entry.key.equals(key)) {
-
V old = entry.value;
-
entry.value = value;
-
return old;
-
}
-
}
-
//如果遍历完，不存在相同的key，则调用addEntry()方法添加元素
-
addEntry(hash, key, value, index);
-
return
null;
-
}
我们可以看到Hashtable类的put()方法加入了synchronized关键字修饰，以确保此方法线程安全。
(8) get()方法
-
//获取指定key的value值，线程安全
-
public synchronized V get(Object key) {
-
Entry<?,?> tab[] = table;
-
//计算hash
-
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;
-
}
-
}
-
//没有返回 null
-
return
null;
-
}
(9) clear()方法
-
//将元素全部置为null，也是线程安全的
-
public synchronized void clear() {
-
Entry<?,?> tab[] = table;
-
modCount++;
-
for (
int index = tab.length; --index >=
0; )
-
tab[index] =
null;
-
count =
0;
-
}
(10) containsKey()方法
-
//判断是否包含key，线程安全
-
public synchronized boolean containsKey(Object key) {
-
Entry<?,?> tab[] = table;
-
int hash = key.hashCode();
-
int index = (hash &
0x7FFFFFFF) % tab.length;
-
//找到“key对应的Entry(链表)”，然后在链表中找出“哈希值”和“键值”与key都相等的元素
-
for (Entry<?,?> e = tab[index] ; e !=
null ; e = e.next) {
-
if ((e.hash == hash) && e.key.equals(key)) {
-
return
true;
-
}
-
}
-
return
false;
-
}
没啥好说的，就是拿key直接转化为坐标index，从index往后找，查找是否存在此key的元素，判断的依据是hash值和key值都要相同。
(11) containsValue()方法
-
public boolean containsValue(Object value) {
-
return contains(value);
-
}
-
-
public synchronized boolean contains(Object value) {
-
//如果value为null直接抛异常
-
if (value ==
null) {
-
throw
new NullPointerException();
-
}
-
-
Entry<?,?> tab[] = table;
-
//循环遍历容器
-
for (
int i = tab.length ; i-- >
0 ;) {
-
for (Entry<?,?> e = tab[i] ; e !=
null ; e = e.next) {
-
if (e.value.equals(value)) {
-
return
true;
-
}
-
}
-
}
-
return
false;
-
}
三、总结
Hashtable类还是要与HashMap来比较着分析，主要有一下几点不同：
* 继承的父类不同：Hashtable类继承自Dictionary这一过时的类；HashMap类继承自AbstractMap类。
* 数据结构不同：Hashtable始终是"数组+链表"的形式；HashMap在jdk1.8后是有"数组+链表"和"数组+红黑树"的形式的。
* 无参初始容量不同：Hashtable无参初始容量为11；HashMap的无参初始容量为16
* hash值计算方式不同：HashTable计算哈希的方式是直接取key本身的hash；而HashMap计算hash的方式为"(key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16) "，即自身哈希和哈希无符号右移16位做与运算。
* 获得索引key的方式不同：Hashtable是“index = (hash & 0x7FFFFFFF) % tab.length”，采用的是取模运算；而HashMap在jdk1.8已经采用“(length - 1) & hash”，把hash值和容量进行“与”操作，这得益于HashMap的容量始终为2的次幂，这样计算效率大大提升。
* 扩容机制不同：一般情况下，Hashtable每次扩容是从n到2n+1；HashMap每次扩容从n变为2n，并且由于HashMap在指定容量进行初始化以及每次扩容时都会调用 inflateTable()方法来保证自己的容器容量始终是2的次幂。
* key和value限制不同：Hashtable不允许key为null，也不允许value为null，源码中我们得知，每次都会判断value是否为null，如果是就直接抛出异常，而key则是在调用key.hashCode()时，如果key为null也会抛出异常；HashMap中的源码在判断key为null后，会设置key的hash值为0，也就是放在桶的第一个位置，代码中也不会value是否为null做限制，那么结论就是HashMap允许一个key为null的元素(再有就覆盖原来的value)，允许多个value为null的元素。
* 线程安全问题：Hashtable中涉及容器变化以及访问的方法，都采用了synchronized关键字修饰，以保证线程安全，相对的效率低一些；HashMap无synchronized修饰，线程不安全，相比Hashtable效率高一些。
值得注意的是Hashtable类似乎也要被淘汰了，jdk1.8的Hashtable类的注释中有写： 如果你不需要线程同步，建议使用HashMap来代替HashTable，如果你的你是需要线程同步的话使用ConcurrentHashMap来替代Hashtable 。
更多精彩内容，敬请扫描下方二维码，关注我的微信公众号【Java觉浅】，获取第一时间更新哦！
转载：https://blog.csdn.net/qq_34942272/article/details/106405975