java.util.Hashtable

定义

           public class Hashtable

           extends Dictionary

           implements Map,Cloneable, Serializable

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

        Hashtable的实例有两个参数影响其性能：初始容量和加载因子。容量是哈希表中桶的数量，初始容量就是哈希表创建时的容量。注意，哈希表的状态为open：在发生“哈希冲突”的情况下，单个桶会存储多个条目，这些条目必须按顺序搜索。加载因子是对哈希表在其容量自动增加之前可以达到多满的一个尺度。初始容量和加载因子这两个参数只是对该实现的提示。关于何时以及是否调用rehash方法的具体细节则依赖于该实现。

        通常，默认加载因子(0.75)在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查找某个条目的时间（在大多数Hashtable操作中，包括get和put操作，都反映了这一点）。

        初始容量主要控制空间消耗与执行rehash操作所需要的时间损耗之间的平衡。如果初始容量大于Hashtable所包含的最大条目数除以加载因子，则永远不会发生rehash操作。但是，将初始容量设置太高可能会浪费空间。

        如果很多条目要存储在一个Hashtable中，那么与根据需要执行自动rehashing操作来增大表的容量的做法相比，使用足够大的初始容量创建哈希表或许可以更有效地插入条目。

        下面这个示例创建了一个数字的哈希表。它将数字的名称用作键：

           Hashtable numbers= new Hashtable();

           numbers.put("one", 1);

           numbers.put("two", 2);

           numbers.put("three", 3);

        要获取一个数字，可以使用以下代码：

          Integer n = numbers.get("two");

          if (n!= null) {

                 System.out.println("two= " + n);

          }

        由所有类的“collection视图方法”返回的collection的iterator方法返回的迭代器都是快速失败的：在创建Iterator之后，如果从结构上对Hashtable进行修改，除非通过Iterator自身的remove方法，否则在任何时间以任何方式对其进行修改，Iterator都将抛出ConcurrentModificationException。因此，面对并发的修改，Iterator很快就会完全失败，而不冒在将来某个不确定的时间发生任意不确定行为的风险。由Hashtable的键和元素方法返回的Enumeration不是快速失败的。

        注意，迭代器的快速失败行为无法得到保证，因为一般来说，不可能对是否出现不同步并发修改做出任何硬性保证。快速失败迭代器会尽最大努力抛出 ConcurrentModificationException。因此，为提高这类迭代器的正确性而编写一个依赖于此异常的程序是错误做法：迭代器的快速失败行为应该仅用于检测程序错误。

   Hashtable是同步的。

构造方法

   Hashtable()：用默认的初始容量 (11) 和加载因子 (0.75) 构造一个新的空哈希表。

   Hashtable(int initialCapacity)：用指定初始容量和默认的加载因子 (0.75) 构造一个新的空哈希表。

   Hashtable(int initialCapacity,float loadFactor)：用指定初始容量和指定加载因子构造一个新的空哈希表。

   Hashtable(MapK,?extendsV> t)：构造一个与给定的 Map 具有相同映射关系的新哈希表。

构造函数源代码：

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

主要方法

首先我们先看put方法：将指定 key 映射到此哈希表中的指定 value。注意这里键key和值value都不可为空。

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值
int index = (hash & 0x7FFFFFFF) % tab.length;     //确认该key的索引位置
//迭代，寻找该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;
}

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

        在put方法中，如果需要向table[]中添加Entry元素，会首先进行容量校验，如果容量已经达到了阀值，HashTable就会进行扩容处理rehash()，如下:

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

        相对于put方法，get方法就会比较简单，处理过程就是计算key的hash值，判断在table数组中的索引位置，然后迭代链表，匹配直到找到相对应key的value，若没有找到返回null。

public synchronized Vget(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与HashMap的区别

        第一：我们从他们的定义就可以看出他们的不同，Hashtable基于Dictionary类，而HashMap是基于AbstractMap。Dictionary是什么？它是任何可将键映射到相应值的类的抽象父类，而AbstractMap是基于Map接口的骨干实现，它以最大限度地减少实现此接口所需的工作。

        第二：HashMap可以允许存在一个为null的key和任意个为null的value，但是Hashtable中的key和value都不允许为null。当HashMap遇到为null的key时，它会调用putForNullKey方法来进行处理。对于value没有进行任何处理，只要是对象都可以。

        第三：Hashtable的方法是同步的，而HashMap的方法不是。所以有人一般都建议如果是涉及到多线程同步时采用Hashtable，没有涉及就采用HashMap，但是在Collections类中存在一个静态方法：synchronizedMap()，该方法创建了一个线程安全的Map对象，并把它作为一个封装的对象来返回，所以通过Collections类的synchronizedMap方法是可以让我们同步访问潜在的HashMap。