Java集合之Map——Hashtable详解

Java集合之Map——Hashtable详解

简介

1. 与HashMap一样，Hashtable也是一个散列表，是以key-value存储形式存在，即主要用来存放键值对；
2. 与HashMap不同，Hashtable的函数都是同步的，这意味着它是线程安全的；
3. Hashtable的key、value都不可以为null，并且，Hashtable中的映射不是有序的；
4. 实现结构是数组+单向链表。

源码解读

继承关系

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

结构图：

• Cloneable空接口，表示可以克隆。 创建并返回HashMap对象的一个副本；
• Serializable序列化接口。属于标记性接口。HashMap对象可以被序列化和反序列化；
• 实现了Map接口，Map接口是声明了key-value键值对的接口；
• 继承于Dictionary抽象类，Dictionary类是声明了操作键值对函数接口的抽象类。

成员变量

与HashMap相比简单了一些。

//哈希表，多个哈希桶组成
private transient HashtableEntry<?,?>[] table;

//HashTable条目数总量
private transient int count;

//哈希表的容量，可容纳元素个数，也称为阈值，为哈希表扩容的临界条件
private int threshold;

//加载因子
private float loadFactor;

//修改次数
private transient int modCount = 0;

大部分与HashMap中变量相似：

• threshold是哈希表能存储的元素个数，也成为阈值，当表中存储元素个数大于阈值时，将会对哈希表进行扩容，即增加桶的个数；
• 源码中出现的capacity代表的是哈希表的大小，即表中哈希桶的个数，table.length，它与阈值不同；
• loadFactor，加载因子，也称负载因子，它表示HashMap的疏密程度，是阈值与哈希桶个数的比值，$loadFactor=\frac{threshold}{table.length}$，实时加载因子为$loadFactor=\frac{size}{table.length}$；

构造方法

1. public Hashtable()，默认构造方法，指定的容量大小是11，加载因子为0.75；
2. public Hashtable(int initialCapacity)，默认初始容量，构造一个具有指定的初始容量和默认加载因子（0.75）；
3. public Hashtable(int initialCapacity, float loadFactor)，构造一个具有指定的初始容量和加载因子的 HashMap；
4. public Hashtable(Map<? extends K, ? extends V> t)，构造一个新的 HashMap与指定的相同的映射 Map 。
   主要分析一下第三个构造方法（前两个方法也是调用第三个方法）：

public Hashtable(int initialCapacity, float loadFactor) {
	//对initialCapacity进行数据可行性处理
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    //对加载因子进行可行性处理
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal Load: "+loadFactor);
	//若指定的容量大小为0,则赋为1 即容量初始大小最小为 1
    if (initialCapacity==0)
        initialCapacity = 1;
    //赋值加载因子
    this.loadFactor = loadFactor;
    //初始化哈希表
    table = new Entry<?,?>[initialCapacity];
    //赋值阈值
    threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
}

成员方法

向表中添加键值对public synchronized V put(K key, V value)

 //这里使用Synchronized锁方法的方式来保证put方法的在多线程下的数据安全
public synchronized V put(K key, V value) {
    // 确定value值不可为null
    if (value == null) {
        throw new NullPointerException();
    }

    // 确定key已经在table中存在 
    HashtableEntry<?,?> tab[] = table;
    //这里取哈希值与HashMap不同，直接用key.hashCode()的值
    int hash = key.hashCode(); 
    //直接取模得到下标值
    int index = (hash & 0x7FFFFFFF) % tab.length;
    @SuppressWarnings("unchecked")
    //得到对应单向链表
    HashtableEntry<K,V> entry = (HashtableEntry<K,V>)tab[index];
    //通过for循环,查找符合条件的key，赋予新的Value，即覆盖原有值
    for(; entry != null ; entry = entry.next) {
        if ((entry.hash == hash) && entry.key.equals(key)) {
            V old = entry.value;
            entry.value = value;
            return old;
        }
    }
    //没有找到键相等的位置，直接头插法插入链表中
    addEntry(hash, key, value, index);
    return null;
}
private void addEntry(int hash, K key, V value, int index) {
    //修改次数+1
    modCount++;

    HashtableEntry<?,?> tab[] = table;
    //如果HashTable的子条目大小 大于 下次扩容大小
    if (count >= threshold) {
        // 如果超过阈值，则重新组织HashTable 即对HashTable进行扩容
        rehash();

        tab = table;
        hash = key.hashCode();
        index = (hash & 0x7FFFFFFF) % tab.length;
    }

    // Creates the new entry.
    @SuppressWarnings("unchecked")
    //将tab中索引位置下的Entry赋予 e
    HashtableEntry<K,V> e = (HashtableEntry<K,V>) tab[index];
    //创建新的HashtableEntry赋予tab中索引位置，头插法
    tab[index] = new HashtableEntry<>(hash, key, value, e);
    //table的条目树+1
    count++;
}

总体流程大致为：

• 判断插入键值对是否合理；
• 通过(key.hashCode() & 0x7FFFFFFF) % tab.length来确定目标哈希桶；
• 遍历桶中元素，若键相等，则进行覆盖；
• 否则调用private void addEntry(int hash, K key, V value, int index)，进行链表头插法；
• 在addEntry方法中，先判断插入键值对后哈希表是否需要扩容，若需要则先扩容，然后重新计算哈希值；
• 最终进行头插法。

移除键值对public synchronized V remove(Object key)

直接通过key的key.hashCode()定位目标桶，然后就是正常的链表删除节点操作：

//这里使用Synchronized 锁方法的方式来保证get函数在多线程下的数据安全
public synchronized V remove(Object key) {
    Entry<?,?> tab[] = table;
    //定位目标哈希桶
    int hash = key.hashCode();
    int index = (hash & 0x7FFFFFFF) % tab.length;
    @SuppressWarnings("unchecked")
    Entry<K,V> e = (Entry<K,V>)tab[index];
    //遍历单项链表找，删除对应节点
    for(Entry<K,V> prev = null ; e != null ; prev = e, e = e.next) {
        if ((e.hash == hash) && e.key.equals(key)) {
            modCount++;
            if (prev != null) {
                prev.next = e.next;
            } else {
                tab[index] = e.next;
            }
            count--;
            V oldValue = e.value;
            e.value = null;
            return oldValue;
        }
    }
    return null;
}

获取元素public synchronized V get(Object key)

直接通过key的key.hashCode()定位目标桶，然后遍历链表找相应元素。

//这里使用Synchronized 锁方法的方式来保证get函数在多线程下的数据安全
public synchronized V get(Object key) {
    HashtableEntry<?,?> tab[] = table;
    //计算下标值
    int hash = key.hashCode();
    int index = (hash & 0x7FFFFFFF) % tab.length;
     //通过for循环来查找如何条件的value
    for (HashtableEntry<?,?> e = tab[index] ; e != null ; e = e.next) {
        if ((e.hash == hash) && e.key.equals(key)) {
            return (V)e.value;
        }
    }
    return null;
}

哈希表的扩容，protected void rehash()

扩容时机：（每次扩容都将哈希表大小扩容成原来的两倍加一）

• 当容器中的元素数量大于阈值（即加载因子乘以哈希表大小）进行扩容。

没有HashMap的那么多细节，直接上代码：

 protected void rehash() {
 	//先存下原哈希表大小
    int oldCapacity = table.length;
    HashtableEntry<?,?>[] oldMap = table;

    // 旧表长度 二进制左移1位+1 当作新表的长度，即两倍+1
    int newCapacity = (oldCapacity << 1) + 1;
    if (newCapacity - MAX_ARRAY_SIZE > 0) {
    //判断新表的大小是否超过上限，是则用上限覆盖
        if (oldCapacity == MAX_ARRAY_SIZE)
            // Keep running with MAX_ARRAY_SIZE buckets
            return;
        newCapacity = MAX_ARRAY_SIZE;
    }
    //创建新表
    HashtableEntry<?,?>[] newMap = new HashtableEntry<?,?>[newCapacity];
    //修改次数+1
    modCount++;
    //更新阈值
    threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
    //将新表赋予当前操作表
    table = newMap;
    //通过for循环将旧表数据赋予新表中
    for (int i = oldCapacity ; i-- > 0 ;) {
        //通过for循环遍历老表索引下的节点数据,赋予新表中
        for (HashtableEntry<K,V> old = (HashtableEntry<K,V>)oldMap[i] ; old != null ; ) {
            HashtableEntry<K,V> e = old;
             //将老表的下一个节点重新赋给old
            old = old.next;
            //头插法将节点插入到新表对应位置
            int index = (e.hash & 0x7FFFFFFF) % newCapacity;
            e.next = (HashtableEntry<K,V>)newMap[index];
            //赋予新表的指定索引位置
            newMap[index] = e;
        }
    }
} 

总结

• 通过上面的分析我们可以清楚地知道，Hashtable的put、get和remove方法在多线程下可以保证数据安全，实现方式都是使用Synchronized同步锁方法的方式实现的。

扩展——与HashMap的比较

散列表	实现方式	是否线程安全	数据安全实现方式	key\value是否可为Null	效率高低
Hashtable	数组+单向链表	是	Synchronized	不可为null	低
HashMap	数组+单向链表/红黑树	否	无	可为null	高