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倍

扩容转移元素时采用的是头插法

 

===== 源码部分解析见注释 =====