我的jdk源码（十四）：Hashtable类

一、概述

    Hashtable类继承于Dictionary抽象类，jdk注释中说明了Dictionary类已经过时，新的实现类应该去实现Map接口，而不是继承Dictionary类。但是面试的时候还是常常会问到Hashtable与HashMap的区别，所以我们还是来看一下Hashtable类的源码，以及现在的实际应用场景中用什么类来代替它。

二、源码分析

    (1) 类的声明

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

    与HashMap类相比，实现的接口完全一致，只是集成的父类不同：Hashtable继承了Dictionary类；HashMap则是继承自AbstractMap类。

    (2) 成员变量

    //存放Entry元素的数组
    private transient Entry<?,?>[] table;
    //实际元素的数量
    private transient int count;
    //扩容的临界容量，threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
    private int threshold;
    //负载因子
    private float loadFactor;
    //修改标记，用于fail-fast机制
    private transient int modCount = 0;
    //指定的序列化标识ID
    private static final long serialVersionUID = 1421746759512286392L;
    //数组最大容量，留8个字节存储对象头，具体可在jvm的学习中了解
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    transient修饰符修饰的成员变量不会被序列化。 

  (3) 构造方法

    //默认无参构造函数，设置默认的容量为11，负载因子为0.75f
    public Hashtable() {
        this(11, 0.75f);
    }

    //指定容量的构造函数
    public Hashtable(int initialCapacity) {
        this(initialCapacity, 0.75f);
    }

    //指定容量和负载因子的构造函数
    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);
        //如果指定容量为0，那么返回的容量为1
        if (initialCapacity==0)
            initialCapacity = 1;
        this.loadFactor = loadFactor;
        table = new Entry<?,?>[initialCapacity];
        threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
    }
    //传入指定的Map返回为Hashtable
    public Hashtable(Map<? extends K, ? extends V> t) {
        //设置容量Math.max(2*t.size(), 11)，取2倍t的元素数量和11比较，取大的值
        this(Math.max(2*t.size(), 11), 0.75f);
        putAll(t);
    }

    不同于HashMap的是，Hashtable在成员变量中并没有设置默认容量，而是在构造函数中设置的，并且默认容量为11；HashMap是成员变量中就设置了初始容量为16。

    (4) Entry<K,V>源码如下：

    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;
        }
        //这里与HashMap的Node不同，HashMap的Node没有clone()方法
        @SuppressWarnings("unchecked")
        protected Object clone() {
            return new Entry<>(hash, key, value,
                                  (next==null ? null : (Entry<K,V>) next.clone()));
        }

        public K getKey() {
            return key;
        }

        public V getValue() {
            return value;
        }
        //设置value时，如果value为null，则直接抛出异常
        public V setValue(V value) {
            if (value == null)
                throw new NullPointerException();

            V oldValue = this.value;
            this.value = value;
            return oldValue;
        }
       
        public boolean equals(Object o) {
            //先判断对象类型是否一致
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            //必须是key和value都相等才返回true
            return (key==null ? e.getKey()==null : key.equals(e.getKey())) &&
               (value==null ? e.getValue()==null : value.equals(e.getValue()));
        }
        //hashCode()与HashMap也不同，HashMap是将key和value的hash值进行异或运算。
        public int hashCode() {
            return hash ^ Objects.hashCode(value);
        }

        public String toString() {
            return key.toString()+"="+value.toString();
        }
    }

    (5) addEntry()方法

    //添加一个Entry元素到指定位置index
    private void addEntry(int hash, K key, V value, int index) {
        //修改标记+1
        modCount++;
        
        Entry<?,?> tab[] = table;
        //如果元素数量超过了限制的数量，就调用rehash()方法进行扩容
        if (count >= threshold) {
            // Rehash the table if the threshold is exceeded
            rehash();

            tab = table;
            //用k的hash值与Integer.MAX_VALUE-1进行&与运算后的结果对table的容量取模获得新下标
            hash = key.hashCode();
            index = (hash & 0x7FFFFFFF) % tab.length;
        }

        //创建新元素，并获取旧元素e的引用
        @SuppressWarnings("unchecked")
        Entry<K,V> e = (Entry<K,V>) tab[index];
        //将index位置设置为新元素，且新元素的下一个元素指定为e，也就是说每次添加元素都是添加在链表头
        tab[index] = new Entry<>(hash, key, value, e);
        //元素总数+1
        count++;
    }

    (6) rehash()方法

    //扩容方法
    protected void rehash() {
        //记录原始的容量为oldCapacity
        int oldCapacity = table.length;
        //记录下原始的容器为oldMap
        Entry<?,?>[] oldMap = table;

        //计算新容量newCapacity的值为2倍oldCapacity的值+1，也就是newCapacity = 2oldCapacity + 1 
        int newCapacity = (oldCapacity << 1) + 1;
        //如果新容量大于数组最大运行容量MAX_ARRAY_SIZE，也就是Integer.MAX_VALUE - 8
        if (newCapacity - MAX_ARRAY_SIZE > 0) {
            //判断原始容量oldCapacity是否已经等于了MAX_ARRAY_SIZE，如果是则直接return
            if (oldCapacity == MAX_ARRAY_SIZE)
                // Keep running with MAX_ARRAY_SIZE buckets
                return;
            //如果原始容量oldCapacity还未达到MAX_ARRAY_SIZE，则将此次新容量newCapacity设置为MAX_ARRAY_SIZE
            newCapacity = MAX_ARRAY_SIZE;
        }
        //用新容量初始化一个Entry数组
        Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];
        //修改标记+1
        modCount++;
        //计算新的扩容临界值threshold，取新容量newCapacity和负载因子loadFactor的乘积与MAX_ARRAY_SIZE + 1中较小的值
        threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
        //将新Map设置为容器
        table = newMap;
        //循环将旧容器oldMap中的元素添加到新容器中
        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;
                //重新计算hash值
                int index = (e.hash & 0x7FFFFFFF) % newCapacity;
                //把newMap原来index下的元素设置为e的下一个元素，并将元素e放在index位置上
                e.next = (Entry<K,V>)newMap[index];
                newMap[index] = e;
            }
        }
    }

    HashTable的扩容机制如下：例如默认初始容量是11，加载因子为0.75，那么扩容阀值就是8，当数组长度达到8的时候，HashTable就会进行一第次扩容，扩容后的容量就是 8 * 2 + 1 = 17 ( int newCapacity = (oldCapacity << 1) + 1) ，此时的扩容阀值就是 17 * 0.75 = 13 ，当下次达到13的时候，就会在重复扩容一次。其实，这个扩容消耗还是蛮大的，因为扩容后需要原来HashTable中的元素一一复制到新的HashTable中。

    (7) put()方法

  //添加一个元素  
  public synchronized V put(K key, V value) {
        // 如果value为null，直接抛出异常
        if (value == null) {
            throw new NullPointerException();
        }
        //获取现有的容器tab[]
        Entry<?,?> tab[] = table;
        //计算桶位,如果key为null,此处会抛异常
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        Entry<K,V> entry = (Entry<K,V>)tab[index];
        //循环遍历是否有相同key的元素存在，如果有就替换旧元素的value值，并且返回旧元素的alue值
        for(; entry != null ; entry = entry.next) {
            if ((entry.hash == hash) && entry.key.equals(key)) {
                V old = entry.value;
                entry.value = value;
                return old;
            }
        }
        //如果遍历完，不存在相同的key，则调用addEntry()方法添加元素
        addEntry(hash, key, value, index);
        return null;
    }

    我们可以看到Hashtable类的put()方法加入了synchronized关键字修饰，以确保此方法线程安全。

    (8) get()方法

    //获取指定key的value值，线程安全
    public synchronized V get(Object key) {
        Entry<?,?> tab[] = table;
   	    //计算hash
        int hash = key.hashCode();
   		//获取下标
        int index = (hash & 0x7FFFFFFF) % tab.length;
   		//遍历链表，找到元素返回
        for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                return (V)e.value;
            }
        }
   		//没有返回 null
        return null;
    }

    (9) clear()方法

    //将元素全部置为null，也是线程安全的
    public synchronized void clear() {
        Entry<?,?> tab[] = table;
        modCount++;
        for (int index = tab.length; --index >= 0; )
            tab[index] = null;
        count = 0;
    }

    (10) containsKey()方法

    //判断是否包含key，线程安全
    public synchronized boolean containsKey(Object key) {
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        //找到“key对应的Entry(链表)”，然后在链表中找出“哈希值”和“键值”与key都相等的元素
        for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                return true;
            }
        }
        return false;
    }

    没啥好说的，就是拿key直接转化为坐标index，从index往后找，查找是否存在此key的元素，判断的依据是hash值和key值都要相同。

    (11) containsValue()方法

 public boolean containsValue(Object value) {
        return contains(value);
    }

public synchronized boolean contains(Object value) {
        //如果value为null直接抛异常
        if (value == null) {
            throw new NullPointerException();
        }

        Entry<?,?> tab[] = table;
        //循环遍历容器
        for (int i = tab.length ; i-- > 0 ;) {
            for (Entry<?,?> e = tab[i] ; e != null ; e = e.next) {
                if (e.value.equals(value)) {
                    return true;
                }
            }
        }
        return false;
    }
    

三、总结

    Hashtable类还是要与HashMap来比较着分析，主要有一下几点不同：

    * 继承的父类不同：Hashtable类继承自Dictionary这一过时的类；HashMap类继承自AbstractMap类。

    * 数据结构不同：Hashtable始终是"数组+链表"的形式；HashMap在jdk1.8后是有"数组+链表"和"数组+红黑树"的形式的。

    * 无参初始容量不同：Hashtable无参初始容量为11；HashMap的无参初始容量为16

    * hash值计算方式不同：HashTable计算哈希的方式是直接取key本身的hash；而HashMap计算hash的方式为"(key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16) "，即自身哈希和哈希无符号右移16位做与运算。

    * 获得索引key的方式不同：Hashtable是“index = (hash & 0x7FFFFFFF) % tab.length”，采用的是取模运算；而HashMap在jdk1.8已经采用“(length - 1) & hash”，把hash值和容量进行“与”操作，这得益于HashMap的容量始终为2的次幂，这样计算效率大大提升。

    * 扩容机制不同：一般情况下，Hashtable每次扩容是从n到2n+1；HashMap每次扩容从n变为2n，并且由于HashMap在指定容量进行初始化以及每次扩容时都会调用 inflateTable()方法来保证自己的容器容量始终是2的次幂。

    * key和value限制不同：Hashtable不允许key为null，也不允许value为null，源码中我们得知，每次都会判断value是否为null，如果是就直接抛出异常，而key则是在调用key.hashCode()时，如果key为null也会抛出异常；HashMap中的源码在判断key为null后，会设置key的hash值为0，也就是放在桶的第一个位置，代码中也不会value是否为null做限制，那么结论就是HashMap允许一个key为null的元素(再有就覆盖原来的value)，允许多个value为null的元素。

    * 线程安全问题：Hashtable中涉及容器变化以及访问的方法，都采用了synchronized关键字修饰，以保证线程安全，相对的效率低一些；HashMap无synchronized修饰，线程不安全，相比Hashtable效率高一些。

    值得注意的是Hashtable类似乎也要被淘汰了，jdk1.8的Hashtable类的注释中有写： 如果你不需要线程同步，建议使用HashMap来代替HashTable，如果你的你是需要线程同步的话使用ConcurrentHashMap来替代Hashtable 。

    更多精彩内容，敬请扫描下方二维码，关注我的微信公众号【Java觉浅】，获取第一时间更新哦！