HashTable跟HashMap在功能上来基本类似，其解决hash冲突的方法也是基于链地址法， 唯一的不同点在HashTable的方法是同步的，多线程操作时，在外部无需使用同步机制
源码解读
1. 成员变量
private transient HashtableEntry<K,V>[] table;
private transient int count;
private int threshold;
private float loadFactor;
private transient int modCount = 0;
HashTable的成员变量跟HashMap的成员变量类似，同样都有loadFactor, modCount, threshold
2. put
public synchronized V put(K key, V value) {
if (value == null) {
throw new NullPointerException();
}
HashtableEntry tab[] = table;
//直接调用key.hashCode()
int hash = hash(key);
//计算索引值
int index = (hash & 0x7FFFFFFF) % tab.length;
//如果已经存在key值相等的entry，用新value替换旧value
for (HashtableEntry<K,V> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
V old = e.value;
e.value = value;
return old;
}
}
modCount++;
if (count >= threshold) {
//扩容至之前容量的两倍
rehash();
tab = table;
hash = hash(key);
index = (hash & 0x7FFFFFFF) % tab.length;
}
// Creates the new entry.
HashtableEntry<K,V> e = tab[index];
tab[index] = new HashtableEntry<>(hash, key, value, e);
count++;
return null;
}
HashTable的put逻辑大体上与HashMap的一致，都可以总结为：
- 计算key值的hash
- 由hash得出索引
- 如果已经存在key值相等的entry，用新value替换旧value
- 递增modCount, 检查是否key-value键值对数量是否达到阈值，如果达到进行扩容操作，扩容至原先容量的两倍
- 创建Entry, 放入数组
但是HashTable中计算hash值和索引值这两步，跟HashMap有很大区别, HashTable是直接获取了key值得hashCode()返回值，然后用求模的方式计算索引，相比于HashMap来说，不仅效率略低，同时由于HashTable并没有硬性要求容量必须是2的n次方，从而会造成index冲突的几率加大，减慢了查询的效率
另外，可以看到HashTable的put方法增加了synchronized关键字，这就意味着put方法是一个同步方法，相对于HashMap的非同步put方法，其在单线程模型下效率肯定会略低
3. get
public synchronized V get(Object key) {
HashtableEntry tab[] = table;
int hash = hash(key);
int index = (hash & 0x7FFFFFFF) % tab.length;
for (HashtableEntry<K,V> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
return e.value;
}
}
return null;
}
get方法也是被synchronized修饰
4. 遍历HashTable
4.1 HashTable.entrySet
public Set<Entry<K,V>> entrySet() {
if (entrySet==null)
entrySet = Collections.synchronizedSet(new EntrySet(), this);
return entrySet;
}
可以看到，获取entrySet时，调用Collections.synchronizedSet来保证Set是同步的
4.2 EntrySet.iterator
private static final int ENTRIES = 2;
public Iterator<Entry<K,V>> iterator() {
return getIterator(ENTRIES);
}
private <T> Iterator<T> getIterator(int type) {
if (count == 0) {
return Collections.emptyIterator();
} else {
return new Enumerator<>(type, true);
}
}
4.3 Enumerator
private class Enumerator<T> implements Enumeration<T>, Iterator<T> {
HashtableEntry[] table = Hashtable.this.table;
...
protected int expectedModCount = modCount;
public T next() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
return nextElement();
}
public T nextElement() {
HashtableEntry<K,V> et = entry;
int i = index;
HashtableEntry[] t = table;
/* Use locals for faster loop iteration */
while (et == null && i > 0) {
et = t[--i];
}
entry = et;
index = i;
if (et != null) {
HashtableEntry<K,V> e = lastReturned = entry;
entry = e.next;
//KEYS代表要获取key的集合， VALUES代表获取value的集合，ENTIRES代表获取entry的集合
return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e);
}
throw new NoSuchElementException("Hashtable Enumerator");
}
}
可以看到HashTable也同样采用Fast-Fail机制，当使用迭代器遍历时，不可以调用HashTable.remove来删除元素，而是应该用迭代器自身的remove方法
