HashTable

public class Hashtable<K,V>
    extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable {
    ...
}

HashMap只实现了Map接口，而HashTable还继承了Dictionary类。但实际上Dictionary类只是一个历史遗留问题，任何新的键值对集合都只需要实现Map接口。

1. 构造方法

/**
 * Constructs a new, empty hashtable with a default initial capacity (11)
 * and load factor (0.75).
 */
public Hashtable() {
    this(11, 0.75f);
}

HashTable的默认容量是11，默认负载因子是0.75。HashMap的这两个值分别是16和0.75。

2. Properties类和Void类

在阅读到HashTable的构造函数时，我看到了一个奇怪的构造函数：

/**
 * A constructor chained from {@link Properties} keeps Hashtable fields
 * uninitialized since they are not used.
 *
 * @param dummy a dummy parameter
 */
Hashtable(Void dummy) {}

首先，在参数列表中出现了一个我从来没见过的类：Void类。我们进入查看这个类的定义。

package java.lang;

/**
 * The {@code Void} class is an uninstantiable placeholder class to hold a
 * reference to the {@code Class} object representing the Java keyword
 * void.
 *
 * @author  unascribed
 * @since   1.1
 */
public final class Void {

    /**
     * The {@code Class} object representing the pseudo-type corresponding to
     * the keyword {@code void}.
     */
    @SuppressWarnings("unchecked")
    public static final Class<Void> TYPE = (Class<Void>) Class.getPrimitiveClass("void");

    /*
     * The Void class cannot be instantiated.
     */
    private Void() {}
}

可以看到，Void类是一个final类，同时只有一个私有的构造函数。显然，这个类既不可以被继承，也不可以被实例化。在doc中我们得知，这是一个占位符类，用于保存对表示Java关键字void的Class对象的引用。

我们可以想到，假如将Void类作为一个方法的返回类型，这意味着这个方法只能返回null。

public Void f(){
    ...
}

那么在这里作为参数的Void类又起到怎样的功能呢？继续阅读构造方法上方的doc，我们发现，这个函数是供java.util.Properties类使用的，Properties类中有下面这个构造函数。

private Properties(Properties defaults, int initialCapacity) {
    // use package-private constructor to
    // initialize unused fields with dummy values
    super((Void) null);
    map = new ConcurrentHashMap<>(initialCapacity);
    this.defaults = defaults;

    // Ensure writes can't be reordered
    UNSAFE.storeFence();
}

Properties类是HashTable类的子类，在这个构造函数中它调用了HashTable中包级私有的构造方法。如果没有这个super语句的话，就会默认调用父类HashTable的无参构造函数，但显然，这是没有必要的。通过在HashTable中添加一个伪构造方法供Properties类调用，可以避免这种无必要的开销。

这里顺便说明一下Properties类。

• Properties类表示一组持久的属性。表示一个持久的属性集，属性列表中每个键及其对应值都是一个字符串。

• Properties 类被许多 Java 类使用。例如，在获取环境变量时它就作为 System.getProperties() 方法的返回值。

• Properties 定义如下实例变量.这个变量持有一个 Properties 对象相关的默认属性列表。

  Properties defaults;
  

3. HashTable中实现线程安全的方式

HashTable中为几乎所有业务方法都添加了synchronized关键字，实现了线程安全。

public synchronized int size() {...}
public synchronized boolean isEmpty() {...}
public synchronized V put(K key, V value) {...}
public synchronized V get(Object key) {...}
public synchronized V remove(Object key) {...}

4. keys方法和elements方法

public synchronized Enumeration<K> keys() {
    return this.<K>getEnumeration(KEYS);
}

public synchronized Enumeration<V> elements() {
    return this.<V>getEnumeration(VALUES);
}

返回了键集合和值集合的枚举。

private <T> Enumeration<T> getEnumeration(int type) {
    if (count == 0) {
        return Collections.emptyEnumeration();
    } else {
        return new Enumerator<>(type, false);
    }
}

下面是作为HashTable类内部类的枚举类

private class Enumerator<T> implements Enumeration<T>, Iterator<T> {
    final Entry<?,?>[] table = Hashtable.this.table;
    int index = table.length;
    Entry<?,?> entry;
    Entry<?,?> lastReturned;
    final int type;

    /**
     * Indicates whether this Enumerator is serving as an Iterator
     * or an Enumeration.  (true -> Iterator).
     */
    final boolean iterator;

    /**
     * The modCount value that the iterator believes that the backing
     * Hashtable should have.  If this expectation is violated, the iterator
     * has detected concurrent modification.
     */
    protected int expectedModCount = Hashtable.this.modCount;

    Enumerator(int type, boolean iterator) {
        this.type = type;
        this.iterator = iterator;
    }

    public boolean hasMoreElements() {
        ...
    }

    @SuppressWarnings("unchecked")
    public T nextElement() {
        Entry<?,?> et = entry;
        int i = index;
        Entry<?,?>[] t = table;
        /* Use locals for faster loop iteration */
        while (et == null && i > 0) {
            et = t[--i];
        }
        entry = et;
        index = i;
        if (et != null) {
            Entry<?,?> e = lastReturned = entry;
            entry = e.next;
            return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e);
        }
        throw new NoSuchElementException("Hashtable Enumerator");
    }

    // Iterator methods
    public boolean hasNext() {
        return hasMoreElements();
    }

    public T next() {
        if (Hashtable.this.modCount != expectedModCount)
            throw new ConcurrentModificationException();
        return nextElement();
    }

    public void remove() {
        ...
    }
}

5. HashTable中定位下标的方法

int index = (hash & 0x7FFFFFFF) % tab.length;

hash & 0x7FFFFFFF是为了保证hash值是一个正数，即二进制下第一位是0。

然后直接对length取模。

6. rehash方法和addEntry方法

protected void rehash() {
    int oldCapacity = table.length;
    Entry<?,?>[] oldMap = table;

    // 扩容逻辑：乘二加一
    int newCapacity = (oldCapacity << 1) + 1;
    if (newCapacity - MAX_ARRAY_SIZE > 0) {
        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;
        }
    }
}

该方法会增加哈希表的容量并在内部重新组织哈希表。当哈希表中的键数超过此哈希表的容量*负载因子时，将自动调用此方法。扩容的逻辑是容量*2+1。

下面的方法用于向表中假如键值对，在put等方法中都有调用。

private void addEntry(int hash, K key, V value, int index) {
    Entry<?,?> tab[] = table;
        if (count >= threshold) {
            // 先调用rehash()
            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++;
        modCount++;
}