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