HashTable源码分析
本文采用jdk1.8来分析HashTable源码
Hashtable和HashMap一样，都是一个哈希表，不允许键和值为null，该类是一个线程安全的，每个方法都加了synchronized关键字
Hashtable继承自Dictionary类，而HashMap继承自AbstractMap，本章不写HashMap相关分析，先有个印象，之后作比较。
public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, java.io.Serializable {HashTable有如下主要属性：
//HashTable的底层是一个Entry数组
private transient Entry<?,?>[] table;
//用来表示entry数组的大小
private transient int count;
//它是HashTable的阈值，用于判断是否需要调整HashTable的容量（threshold = 容量*加载因子）
private int threshold;
//加载因子
private float loadFactor;Entry数组：
private static class Entry<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Entry<K,V> next;
//由equals方法可知，HashTable元素之间相等的条件是，两个元素之间的key和value都相等；
//HashTable不允许key和value相等
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()));
}
}HashTable有四个构造函数：
无参数构造函数：
public Hashtable() {
this(11, 0.75f);
}默认的构造函数又调用了，两个参数的构造函数，由此可以明确，HashTable的默认初始化容量是11，加载因子是0.75，HashMap中数组的默认初始容量是16，并且必须的是2的指数倍数；而Hashtable中默认的初始容量是11，并且不要求必须是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);
}Hashtable在初始化时就创建了Entry数组，而HashMap对底层数组采取的懒加载，即当执行第一次插入时才会创建数组
还有一个参数大小的构造函数，使用默认的加载因子：
public Hashtable(int initialCapacity) {
this(initialCapacity, 0.75f);
}第四个构造函数是传入一个Map参数
public Hashtable(Map<? extends K, ? extends V> t) {
this(Math.max(2*t.size(), 11), 0.75f);
putAll(t);
}
这里我们根据putAll()字面意思猜测，这个函数可能就是把Map里面所有的元素遍历懂到新的HashTable中，我们先看HashTable的get和put操作，putAll也就迎刃而解了。
put操作
put操作前面有一个synchronized关键字，解决了HashMap的并发问题，不过也给HashTable带来了低效率问题。
public synchronized V put(K key, V value) {
// Make sure the value is not null
//HashTable不允许value为null
if (value == null) {
throw new NullPointerException();
}
// Makes sure the key is not already in the hashtable.
Entry<?,?> tab[] = table;
int hash = key.hashCode();
//通过hash值与table长度取余，确定元素的位置
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
Entry<K,V> entry = (Entry<K,V>)tab[index];
// 如果当前位置上存在值，则进行循环，因为位置上的值是以链表形式存储的
for(; entry != null ; entry = entry.next) {
//查找在hash位置相同的情况下，是否有key值相等， 有则替换。
if ((entry.hash == hash) && entry.key.equals(key)) {
V old = entry.value;
entry.value = value;
return old;
}
}
//如果hash相同，key也不重复，那么就进行添加元素操作
addEntry(hash, key, value, index);
return null;
}添加元素addEntry操作
private void addEntry(int hash, K key, V value, int index) {
modCount++;
Entry<?,?> tab[] = table;
//如果元素总量大于threshold
//在容量不超过最大值的时候，阈值等于容量与扩容因子的乘积
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++;
}在添加元素的函数中，有rehash重新扩容的辅助函数：
protected void rehash() {
//旧容量的大小
int oldCapacity = table.length;
Entry<?,?>[] oldMap = table;
// overflow-conscious code
//扩容后的容量是原来容量的2倍+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;
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;
}
}
}注意：扩容后的数组大小是原来的二倍加1，还有就是扩容时插入新元素采用的是头插法，元素会进行倒序
get操作
从源码中可以看出，get方法前面也加了synchronized关键字，所以在并发情况下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) {
//遍历寻找hash和key相等的元素
if ((e.hash == hash) && e.key.equals(key)) {
return (V)e.value;
}
}
//如果未发现元素，则返回null
return null;
}总结：
HashTable是线程安全的，元素无序，不允许key和value为空
HashTable默认容量是11，而HashMap默认容量是16，扩容时容量增长为2*n+1，而HashMap直接增长为2倍
扩容转移元素时采用的是头插法
===== 源码部分解析见注释 =====
