Hashtable源码解析

Hashtable 算是平时用的比较少的一个集合了，先从继承、实现关系 及 构造函数来简单的了解一下

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

    /**
     * The hash table data.
     */
    private transient Entry<?,?>[] table;

    /**
     * Hashtable 中实体数量
     */
    private transient int count;

    // 扩容阀值
    private int threshold;

    // 负载因子
    private float loadFactor;

    // 最大长度
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

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

    // 自定义初始化容量及负载因子构造器
    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);
    }

    // 初始化容量 构造器，默认负载因子 0.75f
    public Hashtable(int initialCapacity) {
        this(initialCapacity, 0.75f);
    }

    // 无参构造器 ， 初始化容量 11 负载因子 0.75f
    public Hashtable() {
        this(11, 0.75f);
    }

    // Map 构造器 初始化容量 以 2倍的Map 与 11 谁大取谁，负载因子 0.75f
    public Hashtable(Map<? extends K, ? extends V> t) {
        this(Math.max(2*t.size(), 11), 0.75f);
        putAll(t);
    }

Hashtable 继承了 Dictionary ，我们都知道 Dictionary 的意思是字典，那么Hashtable 继承了Dictionary 会不会使其有字典的特性呢？ 我们先把这个问题放在这里。全局变量 无非就是定义一些 扩容阀值 threshold 、负载因子 loadFactor、修改次数 modCount等，具体代表的含义已经在字段上注释的很清晰了。

对于支持的构造函数，我看可以看到所有的构造函数最终都是调用的 包含对Hashtable的容量大小及负载因子的构造函数。重点看两个，其一是无参构造函数，从这里面我们看到Hashtable 的默认大小为 11 负载因子为 0.75f 。其二是Map构造函数，其实就是将Map中的所有实体元素 添加到Hashtable中，在此构造函数中，默认的负载因子仍为0.75f，Hashtable 容量大小为 Map 中元素个数的 2 倍 与默认大小 11 中取大值作为初始化容量。

以下我们仍以无参构造为例，通过put 及remove 两个函数来了解 Hashtable 的数据结构。

一、put() 函数

同样我们先看源码，便于了解

    public synchronized V put(K key, V value) {
        // Make sure the value is not null
        if (value == null) {
            throw new NullPointerException();
        }

        // Makes sure the key is not already in the hashtable.
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        Entry<K,V> entry = (Entry<K,V>)tab[index];
        for(; entry != null ; entry = entry.next) {
            if ((entry.hash == hash) && entry.key.equals(key)) {
                V old = entry.value;
                entry.value = value;
                return old;
            }
        }
        addEntry(hash, key, value, index);
        return null;
    }

put 函数由 synchronized 修饰，说明 此函数在多线程环境下是安全的。源码中第三行对value的判断及第九行 获取key的hash值，说明在Hashtable中 key 与 value 均不可为 null 。源码第十行，通过key的hash值计算出在Hashtable应该存储的位置，通过下标index获取当前位置上的元素，如果当前位置没有元素，那么就直接放进去即可。因为在复杂的业务中 Hashtable 中的元素众多，发生hash碰撞是经常的事情，那么在 Hashtable 中是怎么处理 hash 碰撞的呢，我们可以从 addEntry 中看出端倪：

    private void addEntry(int hash, K key, V value, int index) {
        modCount++;

        Entry<?,?> tab[] = table;
        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++;
    }

上面对扩容阀值的判断很好理解，就不一步步梳理了。直接看到最后，先拿到下标为index的元素，然后创建一个新的实体（也可以叫做元素）并赋值给 当前下标。那么到目前为止，还没有看到处理hash碰撞的具体过程，唯一的处理过程就可能在创建新的元素中了，我们继续进入创建元素的函数一观究竟：

    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;
        }
    }

从创建新的元素构造函数我们可以清楚地看到，新创建的元素放置在下标为index的位置，而之前位于index的元素则被赋值给 新元素的next属性。从这里我们可以看到 所有的发生 hash 碰撞的元素，除了放置于index位置的元素，其他元素都会被另一个元素的next 所指向，这不就是一个单向链表吗？而每次由新的元素发生 hash 碰撞的时候 都会插入到这个单向链表的头部。由于Hashtable 初始化时 带层维护的是一个数组，所以我们可以知道 Hashtable 就是一个 数组 + 单向链表的 数据结构。

从 addEntry 函数中可以看到，如果 count 大于或者等于 threshold 是 会进行一次 rehash 也就是我们理解的扩容操作，具体扩容的方式是怎样的呢，我们还是从源码中找到对应的逻辑：

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

        // overflow-conscious code
        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;
            }
        }
    }

重点就在第七行，扩容的的逻辑为 原容量大小的 2倍加1 ，及 newCapacity = 2 * oldCapacity + 1 。

二、remove() 函数

    public synchronized V remove(Object key) {
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        Entry<K,V> e = (Entry<K,V>)tab[index];
        for(Entry<K,V> 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;
    }

remove 函数就比较简单了，源码看起来也是非常简明的，首先根据key获取对应的hash值，然后获取在Hashtable 中的下标，获取下标为index的单向连表，从头部开始，获取对应的元素，并将对应元素的父元素的next 指向 对应元素的next，呢么该元素就相当于从这个链表中脱离掉，以达到删除的目的。如果没有找到对应的元素则不做任何操作。

整个链表的数据结构相信应该十分清楚了，最后附一张结构图，以增加理解。