Hashtable

一.概述

1.定义

Hashtable类实现一个哈希表，该哈希表将键映射到相应的值。任何非 null 对象都可以用作键或值。为了成功地在哈希表中存储和获取对象，用作键的对象必须实现 hashCode 方法和 equals 方法。
HashMap是Hashtable的轻量级实现。
Hashtable定义：

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

HashMap定义：

public class HashMap<K,V>
         extends AbstractMap<K,V>
         implements Map<K,V>, Cloneable, Serializable

Hashtable是基于陈旧的Dictionary类的，HashMap是 Java 1.2引进的Map接口的一个实现。
Hashtable也是继承了Map接口。它们的不同是 Hashtable（since JDK1.0）就继承了Dictionary这个抽象类，而HashMap（since JDK1.2）继承的则是AbstractMap这个抽象类。因为在Hashtable中看到继承Map后所实现的方法是JDK1.2版本时加上去的，估计是在JDK 1.2开发时出于统一的考虑使得Hashtable也继承了Map接口。

2.重要参数

(1)table

为一个Entry[]数组类型，Entry代表了“拉链”的节点，每一个Entry代表了一个键值对，哈希表的”key-value键值对”都是存储在Entry数组中的。

(2)count

HashTable的大小，这个大小并不是HashTable的容器大小，而是他所包含Entry键值对的数量。

(3)threshold

Hashtable的阈值，用于判断是否需要调整Hashtable的容量。
threshold的值=容量count * 加载因子loadFactor。

(4)loadFactor

加载因子。

(5)modCount

用来实现“fail-fast”机制的（也就是快速失败）。所谓快速失败就是在并发集合中，其进行迭代操作时，若有其他线程对其进行结构性的修改，这时迭代器会立马感知到，并且立即抛出ConcurrentModificationException异常，而不是等到迭代完成之后才告诉你（你已经出错了）。

二.构造函数

1.Hashtable()

初始大小为11（Hashmap桶的初始大小为16）

public Hashtable() {
  this(11, 0.75f);
}

2.Hashtable(int initialCapacity)

自定义初始化的容量大小和默认的加载因子 (0.75) 构造一个新的空哈希表。

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，获得大小为initialCapacity的table数组
       table = new Entry[initialCapacity];
       //计算阀值
       threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
       //初始化HashSeed值
       initHashSeedAsNeeded(initialCapacity);
   }

initHashSeedAsNeeded方法用于初始化hashSeed参数，其中hashSeed用于计算key的hash值，它与key的hashCode进行按位异或运算。这个hashSeed是一个与实例相关的随机值，主要用于解决hash冲突。

private int hash(Object k) {
     return hashSeed ^ k.hashCode();
}

3.Hashtable(Map map)

构造一个与给定的 Map 具有相同映射关系的新哈希表。

public Hashtable(Map t) {
   //设置table容器大小，其值==t.size * 2 + 1
     this(Math.max(2*t.size(), 11), 0.75f);
     putAll(t);
 }

三.主要方法

1.put(K key, V value)

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

//同步
public synchronized V put(K key, V value) {
    // 不允许value为null
      if (value == null) {
          throw new NullPointerException();
      }

      /*
       * 确保key在table[]是不重复的
       * 处理过程：
       * 1、计算key的hash值，确认在table[]中的索引位置
       * 2、迭代index索引位置，如果该位置处的链表中存在一个一样的key，则替换其value，返回旧值
       */
      Entry tab[] = table;
      int hash = hash(key);    //计算key的hash值
      //寻找该key的索引位置
      //hash & 0x7FFFFFFF为确保结果hash值为正，然后对table.length取余找到位置
      int index = (hash & 0x7FFFFFFF) % tab.length;     
      //迭代，寻找该key，替换
      for (Entry e = tab[index] ; e != null ; e = e.next) {
          if ((e.hash == hash) && e.key.equals(key)) {
              V old = e.value;
              e.value = value;
              return old;
          }
      }

      modCount++;
      if (count >= threshold) {  //如果容器中的元素数量已经达到阀值，则进行扩容操作
          rehash();
          tab = table;
          hash = hash(key);
          index = (hash & 0x7FFFFFFF) % tab.length;
      }

      // 在索引位置处插入一个新的节点
      Entry e = tab[index];
      tab[index] = new Entry<>(hash, key, value, e);
      //容器中元素+1
      count++;
      return null;
  }

2.rehash()

HashTable的扩容操作，在put方法中，如果需要向table[]中添加Entry元素，会首先进行容量校验，如果容量已经达到了阀值，HashTable就会进行扩容处理rehash()，扩大为新容量=旧容量 * 2 + 1

protected void rehash() {
      int oldCapacity = table.length;
       //元素
       Entry[] oldMap = table;

       //新容量=旧容量 * 2 + 1
       int newCapacity = (oldCapacity << 1) + 1;
       if (newCapacity - MAX_ARRAY_SIZE > 0) {
           if (oldCapacity == MAX_ARRAY_SIZE)
               return;
           newCapacity = MAX_ARRAY_SIZE;
       }

       //新建一个size = newCapacity 的HashTable
       Entry[] newMap = new Entry[];

       modCount++;
       //重新计算阀值
       threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
       //重新计算hashSeed
       boolean rehash = initHashSeedAsNeeded(newCapacity);

       table = newMap;
       //将原来的元素拷贝到新的HashTable中
       for (int i = oldCapacity ; i-- > 0 ;) {
           for (Entry old = oldMap[i] ; old != null ; ) {
               Entry e = old;
               old = old.next;

               if (rehash) {
                   e.hash = hash(e.key);
               }
               int index = (e.hash & 0x7FFFFFFF) % newCapacity;
               e.next = newMap[index];
               newMap[index] = e;
           }
       }
   }

3.hash()

计算hash值，由hash值得出key对应的索引

private int hash(Object k) {
    return hashSeed ^ k.hashCode();
}

4.get(Object key)

计算key的hash值，判断在table数组中的索引位置，然后迭代链表，匹配直到找到相对应key的value,若没有找到返回null。

public synchronized V get(Object key) {
     Entry tab[] = table;
     int hash = hash(key);
     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 e.value;
         }
     }
     return null;
 }

四.遍历方式

前置条件：

    Hashtable<String, Object> hashtable = null; 
    @Before 
    public void init(){
        hashtable = new Hashtable<String, Object>();  
        hashtable.put("now", "you");
        hashtable.put("see", "me");
        hashtable.put("cause", "i");
        hashtable.put("let", "be");
    }

1. 遍历Hashtable的键值对

• 由entrySet()获取Hashtable的“键值对”的Set集合
• 通过Iterator迭代器遍历Set集合

@Test
public void HashTableTraversalTest1(){
    Iterator.Entry> iterator =  hashtable.entrySet().iterator();
    while (iterator.hasNext()) {
         Map.Entry entry = (Map.Entry)iterator.next();
         System.out.println(entry.getKey()+":"+entry.getValue());
    }
}

结果打印：

see:me
now:you
let:be
cause:i

2.通过Iterator遍历Hashtable的键

(1)获取keys集合方式1

• 由keySet()获取Hashtable的“键”的Set集合
• 通过Iterator迭代器遍历Set集合的key
• 如需要获取value，由key再定位获取到value

@Test
public void HashTableTraversalTest2(){
    Iterator iterator =  hashtable.keySet().iterator();
    while (iterator.hasNext()) {
         String key = iterator.next();
         System.out.println(key+":"+hashtable.get(key));
    }
}

(2)获取keys集合方式2

• 由hashtable.keys()方法获取keys获取Hashtable的Enumeration集合
• 通过Iterator迭代器遍历Enumeration集合的值
• 如需要获取value，由key再定位获取到value

@Test
public void HashTableTraversalTest3(){
    Enumeration enumeration =  hashtable.keys();
    while (enumeration.hasMoreElements()) {
        String string = (String) enumeration.nextElement();          
        System.out.println(string+":"+hashtable.get(string));
    }
}

3.通过Iterator遍历Hashtable的值

(1)获取values集合方式1

• 由keySet()获取Hashtable的“键”的Collection
• 通过Iterator迭代器遍历Collection

@Test
public void HashTableTraversalValuesTest4(){
    Collection