Java8 源码学习 - HashTable

HashTable继承与Dictionary--并实现了 Map|Cloneable|Serializable接口

---

Dictionary

    此类的注释提到：

The <code>Dictionary</code> class is the abstract parent of any class, such as <code>Hashtable</code>, which maps keys to values.

       刚开始看的时候，我都懵逼了，我还仔细想了想，以我的了解好像只有HashTable继承了这个抽象类。。。可以看到后面的

NOTE: This class is obsolete.  New implementations should implement the Map interface, rather than extending this class

     这个接口已经被废弃了，现在还保留的原因大概是是因为兼容之前使用这个类的系统

---

HashTable的解析

     注意：HashMap实现储存键值对的方法是：链接地址法

        即：使用数组+链表 ==>当向Map中新增一个键值对是，然后先将KEY通过自己的hash算法，并通过hashcode对动态数组的长度取模来获取数组的索引并储存，当遇上此索引出有值即两个键值对的KEY的hashcode运算一样时，便实行链表机制，当链表过长且数组过大时会将某一段链表转换为树来储存       

《类似桶排序》   

其与hashmap所实现的功能相同--实现方式也差不多，但由于hashmap改进多次所以效率较高

HashTable的成员变量 

private transient Entry<?,?>[] table;//哈希表

private transient int count; //哈希表所储存的实体的总数，并非哈希表的长度

private int threshold;//当前table中键值对的数量阙值

private float loadFactor;//负载因子

private transient int modCount = 0;//哈希表结构改变次数

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;//哈希表的长度最大值

注意：hashMap的成员变量没有用private修饰，个人暂时认为这一点HashTable更好一点,HashTable没有一些默认的常量但有默认的需要值，相对而言具有常量的HashMap更具有代码的可读性--如下：

HashTable的方法    

public Hashtable(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        if (loadFactor <= 0 || Float.isNaN(loadFactor))//isNaN(loadFactor)判断是否，是一个合法的float类型的数据
            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);//此句起限制哈希表大小的作用
}
public Hashtable(int initialCapacity) {
        this(initialCapacity, 0.75f);//默认的负载因子
}
public Hashtable() {
        this(11, 0.75f); //默认的容量是11--hashMap默认是16
}
public Hashtable(Map<? extends K, ? extends V> t) {
        this(Math.max(2*t.size(), 11), 0.75f);//如果使用现有的map构造，则容量为其map中实体数量的2倍或11此处与hashmap不同
        putAll(t);
}

获取表的索引的过程:

        通过KEY的--> key.hashCode();获取object原生的hashcode（其决定了hashtable的key不能为空）-->index = (hash & 0x7FFFFFFF) % tab.length;(将hashcode绝对值化然后对表的长度取模)

public synchronized V put(K key, V value) 
 public synchronized V put(K key, V value) {
        // Make sure the value is not null
        if (value == null) {     //hashTable不允许value为空
            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;
            }
        }//会覆盖原有的vaule,但会返回原有的value值--hashmap一样
        addEntry(hash, key, value, index);
        return null;
    }
protected void rehash()
 protected void rehash() {
        HashtableEntry e, old;
        int i, index;
        int oldCapacity = table.length;
        HashtableEntry oldTable[] = table;
        int newCapacity = oldCapacity * 2 + 1;//扩容算法不同于hashmap
        HashtableEntry newTable[] = new HashtableEntry[newCapacity];
        threshold = (int)(newCapacity * loadFactor);
        table = newTable;
        for (i = oldCapacity ; i-- > 0 ;) {
            for (old = oldTable[i] ; old != null ; ) {
                e = old;
                old = old.next;
                index = (e.hash & 0x7FFFFFFF) % newCapacity;
                e.next = newTable[index];
                newTable[index] = e;
            }
        }
    }

HashTable所有方法都用synchronized关键字修饰，因此是线程安全的--不允许key value为空