Java Hashtable 源码(JDK8)

记录了HashMap也来看看Hashtable吧，最近打算换份实习，所以想看看书回顾一下，不然就快记不得了.....囧啊囧啊，记性太差怎么破？？？

Hashtable里面的一些变量：

Entry<?,?>[] table : HashTable采用"拉链法"实现哈希表,每一个Entry代表了一个键值对(key-value)。

transient int count:hashtable里面键值对的个数;

private int threshold：hashtable的阀值（threshols = capacity * loadFactor);

float loadFactor:加载因子;

transient int modCount ：hashtable被修改的次数，用来实现fast-fail机制。fast-fail机制就是在并发集合中，其进行迭代操作时，若有其他线程对其进行结构性的修改，这时迭代器会立马感知到，并且立即抛出　　　　　　　　　　　　　　ConcurrentModificationException异常。

Hashtable的定义如下：

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

可以看出Hashtable实现了Map接口，同时继承了Dictionary类。Map接口是将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。Dictionary 类是任何可将键映射到相应值的类（如 Hashtable）的抽象父类。每个键和每个值都是一个对象。在任何一个 Dictionary 对象中，每个键至多与一个值相关联。给定一个 Dictionary 和一个键，就可以查找所关联的元素。任何非 null 对象都可以用作键或值。

看看Hashtable常用的构造函数的实现：

默认的构造函数：容量为11，加载因子为0.75

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);
            
            if (initialCapacity==0)
                initialCapacity = 1;
            this.loadFactor = loadFactor;
            //用指定容量初始化table数组
            table = new Entry<?,?>[initialCapacity];
            //计算table的阀值
            threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
        }

再来看看Put方法和get方法：

　　首先是put方法，put方法的整个处理流程是：计算key的hash值，根据hash值获得key在table数组中的索引位置，然后迭代该key处的Entry链表（我们暂且理解为链表），若该链表中存在一个这个的key对象，那么就直接替换其value值即可，否则在将改key-value节点插入该index索引位置处。注意，hashtable是不允许null值的。

int index = (hash & 0x7FFFFFFF) % tab.length——>键的hash值可能为负数，通过一个“与”操作，先将hash值都转化正数，然后将得到的hash值与Hashtable的长度求余

 //同步实现
     public synchronized V put(K key, V value) {
            // check value值是否为null
            if (value == null) {
                throw new NullPointerException();
            }

            // Makes sure the key is not already in the hashtable.
            Entry<?,?> tab[] = table;
            //计算key的hash值
            int hash = key.hashCode();
            //通过hash值来计算在table数组中的下表
            int index = (hash & 0x7FFFFFFF) % tab.length;
            @SuppressWarnings("unchecked")
            Entry<K,V> entry = (Entry<K,V>)tab[index];
            //遍历，寻找该key,找到则替换旧值
            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(hash, key, value, index);
            return null;
        }
         private void addEntry(int hash, K key, V value, int index) {
                 //修改链表，modCount自增
                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++;
        }

get方法也是同步的，具体的实现如下：

 public synchronized V get(Object key) {
            Entry<?,?> tab[] = table;
            //计算key的hash值
            int hash = key.hashCode();
            //通过hash值来计算在table数组中的下表
            int index = (hash & 0x7FFFFFFF) % tab.length;
            //遍历查找key，找到则返回key值所对应的的value
            for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
                if ((e.hash == hash) && e.key.equals(key)) {
                    return (V)e.value;
                }
            }
            return null;
        }