Java集合（8）：Hashtable

一.Hashtable介绍

　　和HashMap一样，Hashtable 也是一个散列表，它存储的内容是键值对(key-value)映射，它在很大程度上和HashMap的实现差不多。

　　Hashtable 的函数都是同步的，这意味着它是线程安全的。它的key、value都不可以为null。此外，Hashtable中的映射不是有序的。

1.Hashtable的继承关系

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

2.Hashtable的类图关系

　　HashTable继承Dictionary类，实现Map接口。其中Dictionary类是任何可将键映射到相应值的类的抽象父类。每个键和每个值都是一个对象。在任何一个 Dictionary 对象中，每个键至多与一个值相关联。Map是”key-value键值对”接口。

二.Hashtable源码解析

1.Hashtable的私有属性

private transient Entry<?,?>[] table;//table是一个Entry[]数组类型，而Entry实际上就是一个单向链表。
private transient int count;//count是Hashtable的大小，它是Hashtable保存的键值对的数量。 
private int threshold;//threshold是Hashtable的阈值，用于判断是否需要调整Hashtable的容量。threshold的值="容量*加载因子"。
private float loadFactor;//loadFactor就是加载因子。 
private transient int modCount = 0;//modCount是用来实现fail-fast机制的

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

2.Hashtable的构造方法

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

// 包含“子Map”的构造函数
public Hashtable(Map<? extends K, ? extends V> t) {
    this(Math.max(2*t.size(), 11), 0.75f);//设置table容器大小，其值==t.size * 2 + 1
    putAll(t);
}

3.存储数据put

将指定 key 映射到此哈希表中的指定 value。注意这里键key和值value都不可为空。

public synchronized V put(K key, V value) {
    if (value == null) {// 确保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的索引位置
    for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) { //迭代，寻找该key，替换
        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<K,V> e = tab[index];// 在索引位置处插入一个新的节点
    tab[index] = new Entry<>(hash, key, value, e);
    count++;//容器中元素+1
    return null;
}

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

过程演示如下：

　　首先我们假设一个容量为5的table，存在如下的键值对：

　　然后我们插入一个数：put(16,22)，key=16在table的索引位置为1，同时在1索引位置有两个数，程序对该“链表”进行迭代，发现存在一个key=16,这时要做的工作就是用newValue=22替换oldValue16，并将oldValue=16返回。

　　在put(33,33)，key=33所在的索引位置为3，并且在该链表中也没有存在某个key=33的节点，所以就将该节点插入该链表的第一个位置。

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

protected void rehash() {
    int oldCapacity = table.length;
    Entry<K,V>[] oldMap = table;

    int newCapacity = (oldCapacity << 1) + 1;//新容量=旧容量 * 2 + 1
    if (newCapacity - MAX_ARRAY_SIZE > 0) {
        if (oldCapacity == MAX_ARRAY_SIZE)
            return;
        newCapacity = MAX_ARRAY_SIZE;
    }
    Entry<K,V>[] newMap = new Entry[];//新建一个size = newCapacity 的HashTable
    modCount++;
    threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);//重新计算阀值
    boolean rehash = initHashSeedAsNeeded(newCapacity);//重新计算hashSeed
    table = newMap;
    for (int i = oldCapacity ; i-- > 0 ;) {//将原来的元素拷贝到新的HashTable中
        for (Entry<K,V> old = oldMap[i] ; old != null ; ) {
            Entry<K,V> 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;
        }
    }
}

　　通过上面rehash代码我们可以看到容量扩大两倍+1，同时需要将原来HashTable中的元素一一复制到新的HashTable中，这个过程是比较消耗时间的，同时还需要重新计算hashSeed的，毕竟容量已经变了。

　　关于阀值：比如初始值11、加载因子默认0.75，那么这个时候阀值threshold=8，当容器中的元素达到8时，HashTable进行一次扩容操作，容量 = 8 * 2 + 1 =17，而阀值threshold=17*0.75 = 13，当容器元素再一次达到阀值时，HashTable还会进行扩容操作，一次类推。

4.数据读取get()

　　相对于put方法，get方法就会比较简单，处理过程就是计算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<K,V> e = tab[index] ; e != null ; e = e.next) {
        if ((e.hash == hash) && e.key.equals(key)) {
            return e.value;
        }
    }
    return null;
}

5.其他方法

三.Hashtable的遍历

1.遍历Hashtable的键值对（效率较高）

第一步：根据entrySet()获取Hashtable的“键值对”的Set集合。
第二步：通过Iterator迭代器遍历“第一步”得到的集合。

// 假设table是Hashtable对象
// table中的key是String类型，value是Integer类型
Integer integ = null;
Iterator iter = table.entrySet().iterator();
while(iter.hasNext()) {
    Map.Entry entry = (Map.Entry)iter.next();
    // 获取key
    key = (String)entry.getKey();
        // 获取value
    integ = (Integer)entry.getValue();
}

2.通过Iterator遍历Hashtable的键（效率较低）

第一步：根据keySet()获取Hashtable的“键”的Set集合。
第二步：通过Iterator迭代器遍历“第一步”得到的集合。

// 假设table是Hashtable对象
// table中的key是String类型，value是Integer类型
String key = null;
Integer integ = null;
Iterator iter = table.keySet().iterator();
while (iter.hasNext()) {
        // 获取key
    key = (String)iter.next();
        // 根据key，获取value
    integ = (Integer)table.get(key);
}

3.通过Iterator遍历Hashtable的值

第一步：根据value()获取Hashtable的“值”的集合。
第二步：通过Iterator迭代器遍历“第一步”得到的集合。

// 假设table是Hashtable对象
// table中的key是String类型，value是Integer类型
Integer value = null;
Collection c = table.values();
Iterator iter= c.iterator();
while (iter.hasNext()) {
    value = (Integer)iter.next();
}

4.通过Enumeration遍历Hashtable的键（效率较高）

第一步：根据keys()获取Hashtable的集合。
第二步：通过Enumeration遍历“第一步”得到的集合。

Enumeration enu = table.keys();
while(enu.hasMoreElements()) {
    System.out.println(enu.nextElement());
}  

5.通过Enumeration遍历Hashtable的值（效率较高）

第一步：根据elements()获取Hashtable的集合。
第二步：通过Enumeration遍历“第一步”得到的集合。

Enumeration enu = table.elements();
while(enu.hasMoreElements()) {
    System.out.println(enu.nextElement());
}

四.HashTable和HashMap的比较

　　HashTable的应用非常广泛，HashMap是新框架中用来代替HashTable的类，也就是说建议使用HashMap。

下面着重比较一下二者的区别：

1.继承不同

Hashtable是基于陈旧的Dictionary类的，HashMap是java 1.2引进的Map接口的一个实现。

2.同步

Hashtable 中的方法是同步的，保证了Hashtable中的对象是线程安全的。

HashMap中的方法在缺省情况下是非同步的,HashMap中的对象并不是线程安全的。在多线程并发的环境下，可以直接使用Hashtable，但是要使用HashMap的话就要自己增加同步处理了。

3.效率

单线程中, HashMap的效率大于Hashtable。因为同步的要求会影响执行的效率，所以如果你不需要线程安全的集合，HashMap是Hashtable的轻量级实现，这样可以避免由于同步带来的不必要的性能开销，从而提高效率。

4.null值

Hashtable中，key和value都不允许出现null值，否则出现NullPointerException。

在HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。当get()方法返回null值时，即可以表示 HashMap中没有该键，也可以表示该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键，而应该用containsKey()方法来判断。

5.遍历方式

Hashtable、HashMap都使用了 Iterator。而由于历史原因，Hashtable还使用了Enumeration的方式。

6.容量

Hashtable和HashMap它们两个内部实现方式的数组的初始大小和扩容的方式。

HashTable中hash数组默认大小是11，增加的方式是 old*2+1。

HashMap中hash数组的默认大小是16，而且一定是2的指数。 

小结：

　　无论什么时候有多个线程访问相同实例的可能时，就应该使用Hashtable，反之使用HashMap。非线程安全的数据结构能带来更好的性能。

　　如果在将来有一种可能—你需要按顺序获得键值对的方案时，HashMap是一个很好的选择，因为有HashMap的一个子类 LinkedHashMap。所以如果你想可预测的按顺序迭代（默认按插入的顺序），你可以很方便用LinkedHashMap替换HashMap。反观要是使用的Hashtable就没那么简单了。同时如果有多个线程访问HashMap，Collections.synchronizedMap（）可以代替，总的来说HashMap更灵活。

参考：http://cmsblogs.com/?p=618

http://blog.csdn.net/zheng0518/article/details/42199477

http://www.cnblogs.com/devinzhang/archive/2012/01/13/2321481.html