07.Java 集合 - HashTable

基本概念

1.结构

首先来看它的继承结构：

再来看看它的结构图，HashTable 是基于哈希表（hash table）实现的map。而哈希表的组成是一个数组，而数组的元素是则单向链表的首节点。

---

2.特点

线程安全，并且不允许 key 或 value 为 null 。

与 HasMap 的底层结构相同，不同的是：

• HashMap 允许 key，value 为 null；

• HashMap 的初始容量必须为 2 的倍数，而 HashTable 只要求不为 0 即可；

• 关于数组索引位置的计算公式不同。

---

3.初始容量 和加载因子

Hashtable 的实例有两个参数影响其性能：初始容量 和加载因子。

• 容量，是哈希表中桶（bucket）的数量，初始容量 就是哈希表创建时的容量。在发生“哈希冲突”的情况下，单个桶会存储多个条目，这些条目必须按顺序搜索。

• 初始容量，主要控制空间消耗与执行 rehash 操作所需要的时间损耗之间的平衡。如果初始容量大于 Hashtable 所包含的最大条目数除以加载因子，则永远 不会发生 rehash 操作。但是，将初始容量设置太高可能会浪费空间。

• 加载因子，是对哈希表在其容量自动增加之前可以达到多满的一个尺度。

• 默认加载因子(.75)，在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查找某个条目的时间（在大多数 Hashtable 操作中，包括 get 和 put 操作，都反映了这一点）。

---

源码分析

1.节点

HashTable 中存放的元素，也称节点，由 Entry 构成。结构如图所示：

观察它的构造函数，是由 h（哈希值），key（键），value（值）,Entry（下一个节点）这几个参数组成。

• 通过 key-value 构成了 map 的 映射关系

• 通过 Entry （即 next）连接它的下一节点，构成了单向链表

private static class Entry<K, V> implements Map.Entry<K, V> {
    int hash; 
    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;
    }

    // 计算哈希码值
    public int hashCode() {
        return hash ^ (value == null ? 0 : value.hashCode());
    }

    //....省略剩余方法
}

---

2.构造函数

观察代码构造函数 ①~③ 都调用了构造函数 ④ 。

而该方法主要完成了参数的初始化（loadFactor，threshold）以及数组（table []）的创建工作。

注意：在 HashMap 中，初始化容量（initialCapacity） 必须是 2 的倍数，而 HashTable 只要求不为 0 即可。

// 内部数组
private transient Entry[] table;

// 加载因子
private float loadFactor;

// 临界值
private int threshold;

// 实际存放元素个数
private transient int count;

// 修改次数
private transient int modCount = 0;

// ①
public Hashtable() {
    this(11, 0.75f);
}

// ②
public Hashtable(int initialCapacity) {
    this(initialCapacity, 0.75f);
}

// ③
public Hashtable(Map<? extends K, ? extends V> t) {
    this(Math.max(2 * t.size(), 11), 0.75f);

    // 添加 map 的所有映射（在添加操作会介绍）
    putAll(t);
}

// ④ --> 负责具体实现
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);
    }

    // 在 HashMap 初始化容量必须为 2的倍数 
    if (initialCapacity == 0) {
        initialCapacity = 1;
    }

    // 初始化参数，并创建数组
    this.loadFactor = loadFactor;
    table = new Entry[initialCapacity];
    threshold = (int) (initialCapacity * loadFactor);
}

---

3.添加操作（putAll，put）

这里提供了两种了添加方式， putAll 会去遍历指定 map 的所有 key-value，然后再调用 put 将其逐个添加进哈希表。因此重点来看 put 的工作流程，如下图所示：

• 判断 value 是否为空，为空抛出。与 HashMap 不同， 在 HashTable 中不允许空值，而 HashMap 则允许。

• 计算 key-value 在哈希表中的位置。同样，这里的计算公式也与 HashMap 有差别。

• 找到该位置的节点（table 数组中存放的都是单链表的首节点），遍历操作。

• 比较 key，存在则替换 key；

• 不存在，先扩充容量。再添加 key-value 作用新的首节点。

//添加指定的 map 
public synchronized void putAll(Map<? extends K, ? extends V> t) {
    // 遍历 Map 的映射关系
    for (Map.Entry<? extends K, ? extends V> e : t.entrySet()) {
        // 添加一个映射关系
        put(e.getKey(), e.getValue());
    }
}


//添加单个映射关系
public synchronized V put(K key, V value) {

    // 与 HashMap 不同，不允许 value 为空
    if (value == null) {
        throw new NullPointerException();
    }

    Entry tab[] = table;

    // 与 HashMap 计算方式不同，计算得到数组的索引位置
    int hash = key.hashCode();
    int index = (hash & 0x7FFFFFFF) % tab.length;

    // 遍历该位置的单链表
    for (Entry<K, V> e = tab[index]; e != null; e = e.next) {

        // 存在相同的 key，替换 value，并返回旧值
        if ((e.hash == hash) && e.key.equals(key)) {
            V old = e.value;
            e.value = value;
            return old;
        }
    }

    // 若不存在相同的 key，扩充完容量，并重新计算索引值
    modCount++;
    if (count >= threshold) {
        // 扩充容量
        rehash();
        tab = table;

        // 重新计算索引位置
        index = (hash & 0x7FFFFFFF) % tab.length;
    }

    // 添加新节点为首节点
    Entry<K, V> e = tab[index];
    tab[index] = new Entry<K, V>(hash, key, value, e);

    count++;
    return null;
}


// 调整 HashTable 的容量，=（旧容量*2+1）
protected void rehash() {
    int oldCapacity = table.length;
    Entry[] oldMap = table;
    // 扩充容量
    int newCapacity = oldCapacity * 2 + 1;
    // 创建新数组
    Entry[] newMap = new Entry[newCapacity];
    modCount++;
    threshold = (int) (newCapacity * loadFactor);
    table = newMap;
    // 复制元素到新数组
    for (int i = oldCapacity; i-- > 0;) {
        for (Entry<K, V> old = oldMap[i]; old != null;) {
            Entry<K, V> e = old;
            old = old.next;
            int index = (e.hash & 0x7FFFFFFF) % newCapacity;
            e.next = newMap[index];
            newMap[index] = e;
        }
    }
}

---

4.删除操作（remove，clear）

同样有两种删除操作。重点来看下 remove 。观察代码，发现与 put 的流程相似。不同的是 put 是添加/修改，而它是删除。

这里来分析删除操作，即从单链表中移除节点的具体流程：

• 首先要判断是不是首节点

• 若是首节点的话，则将它的下一节点设为数组元素（因为在数组中存在的都是单链表的首节点）。并将该节点置空，等待 gc 回收。

• 若不是，则需要修改该节点前置节点的指针，将其指向该节点的下一节点。如下图所示：

// 移除指定的映射关系
public synchronized V remove(Object key) {

    Entry tab[] = table;
    int hash = key.hashCode();
    int index = (hash & 0x7FFFFFFF) % tab.length;

    for (Entry<K, V> e = tab[index], 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;
}


// 清空操作
public synchronized void clear() {
    Entry tab[] = table;
    modCount++;
    for (int index = tab.length; --index >= 0;) {
        tab[index] = null;
    }
    count = 0;
}

---

5.查询操作（get，containsKey，contains）

观察 get 与 containsKey 的代码，发现二者的代码基本相同。甚至与 remove，put 也相差不大。

都遵循了[计算哈希值 -> 计算索引位置 -> 遍历单链表 -> 判断 key 是否相同 -> …] 这几个步骤。

因此这里重点来看下 contains 方法，它与 get，containsKey 不同。由于不能通过 value 得到数组的索引位置，只能遍历整个哈希表的元素（节点）。

因此它的步骤是 [判断是否为空 -> 遍历数组 -> 遍历单链表 -> 比较 value是否相同 -> …]

// 根据 key 找到对应的 value
public synchronized V get(Object key) {
    Entry tab[] = table;
    int hash = key.hashCode();
    int index = (hash & 0x7FFFFFFF) % tab.length;

    for (Entry<K, V> e = tab[index]; e != null; e = e.next) {
        if ((e.hash == hash) && e.key.equals(key)) {
            return e.value;
        }
    }
    return null;
}


// 判断是否包含指定的 key
public synchronized boolean containsKey(Object key) {
    Entry tab[] = table;
    int hash = key.hashCode();
    int index = (hash & 0x7FFFFFFF) % tab.length;

    for (Entry<K, V> e = tab[index]; e != null; e = e.next) {
        if ((e.hash == hash) && e.key.equals(key)) {
            return true;
        }
    }
    return false;
}


// 判断是否包含指定的 value
public synchronized boolean contains(Object value) {
    // 不允许 value 为空
    if (value == null) {
        throw new NullPointerException();
    }
    Entry tab[] = table;

    // 从后向前遍历数组（因为不能从 value 计算中节点在哈希表中的位置 ）
    for (int i = tab.length; i-- > 0;) {
        for (Entry<K, V> e = tab[i]; e != null; e = e.next) {
            // 与 key 不同，只比较值
            if (e.value.equals(value)) {
                return true;
            }
        }
    }
    return false;
}

---

6.遍历操作(entrySet，keySet，values)

分别实现了对 Entry（节点），key，value 的遍历操作。

以 entrySet 为例，该方法通过 Collections 的同步方法创建了一个 Hashtable.EntrySet（内部类） 的实例；

相应的 keySet ，values 分别创建了 Hashtable.KeySet，Hashtable.AbstractCollection 的实例。

private transient volatile Set<Map.Entry<K, V>> entrySet = null; 

public Set<Map.Entry<K, V>> entrySet() {
    if (entrySet == null) {
        entrySet = Collections.synchronizedSet(new EntrySet(), this);
    }
    return entrySet;
}

以 Hashtable.EntrySet 为例子，重点来看它的 iterator 方法。

private static final int KEYS = 0;
private static final int VALUES = 1;
private static final int ENTRIES = 2;

private class EntrySet extends AbstractSet<Map.Entry<K, V>> {

    // 迭代器
    public Iterator<Map.Entry<K, V>> iterator() {
        return getIterator(ENTRIES);
    }

    //...省略部分代码
}

在三个内部类的 iterator 方法中都调用 getIterator 方法来创建迭代器，通过传入的 type 区分类型。

在 getIterator 中，首先会判断哈希表的元素个数。若为 0，返回 HshTable.EmptyIterator；不为 0，返回 HshTable.Enumerator。

private static Iterator emptyIterator = new EmptyIterator();

private <T> Iterator<T> getIterator(int type) {
    if (count == 0) {
        return (Iterator<T>) emptyIterator;
    } else {
        return new Enumerator<T>(type, true);
    }
}

下面来分析下 Enumerator 的源码，当它表示迭代器时可以操作 next，hasNext ，remove方法；当它表示枚举类时，不能操作 remove 方法。

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

    // Enumerator是 “迭代器(Iterator)” 还是 “枚举类(Enumeration)”的标志
    // 为true，表示它是迭代器；否则，是枚举类
    boolean iterator;

    // 在将Enumerator当作迭代器使用时会用到，用来实现fail-fast机制。
    protected int expectedModCount = modCount;

    // 构造函数
    Enumerator(int type, boolean iterator) {
        this.type = type;
        this.iterator = iterator;
    }

    // 关键--> 判断迭代器是否还有数据
    public boolean hasNext() {
        return hasMoreElements();
    }

    public boolean hasMoreElements() {
        Entry<K, V> e = entry;
        int i = index;
        Entry[] t = table;

        // 从后向前遍历数组元素
        while (e == null && i > 0) {
            e = t[--i];
        }
        entry = e;
        index = i;
        return e != null;
    }

    // 关键 --> 取得下一个节点
    public T next() {
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        return nextElement();
    }

    public T nextElement() {
        Entry<K, V> 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<K, V> e = lastReturned = entry;
            entry = e.next;
            return type == KEYS ? (T) e.key : (type == VALUES ? (T) e.value : (T) e);
        }
        throw new NoSuchElementException("Hashtable Enumerator");
    }

    // 移除当前迭代的节点
    public void remove() {
        // 当该类表示迭代器时才能调用该方法
        if (!iterator) {
            throw new UnsupportedOperationException();
        }

        if (lastReturned == null) {
            throw new IllegalStateException("Hashtable Enumerator");
        }

        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }

        synchronized (Hashtable.this) {
            Entry[] tab = Hashtable.this.table;
            int index = (lastReturned.hash & 0x7FFFFFFF) % tab.length;

            // 计算索引位置，遍历单链表
            for (Entry<K, V> e = tab[index], prev = null; e != null; prev = e, e = e.next) {
                // 判断是不是当前迭代的节点
                if (e == lastReturned) {
                    modCount++;
                    expectedModCount++;
                    if (prev == null) {
                        tab[index] = e.next;
                    } else {
                        prev.next = e.next;
                    }
                    count--;
                    lastReturned = null;
                    return;
                }
            }
            throw new ConcurrentModificationException();
        }
    }
}

---

7.工具类方法

public synchronized int size() {
    return count;
}

public synchronized boolean isEmpty() {
    return count == 0;
}