java HashTable源码解析

一、概述

1.HashTable也是一个散列表，它存储的内容是键值对（key-value）映射，与HashMap不同的是HashTable的key和value不允许为空。

2.HashTable的方法都是同步的，所以他是线程安全的。

3.HashTable中的映射不是有序的。

二、HashTable中的主要方法

1、HashTable中的几个主要的变量

//保存key-value的数组
private transient Entry[] table;

//hashTable中数组元素的个数
private transient int count;

//阈值，用来判断是否要对数组的容量进行调整
private int threshold;

//加载因子
private float loadFactor;

//hashTable被改变的次数
private transient int modCount = 0;

2.HashTable的Entry实体

    HashTable中存储的对象是Entry实体，Entry是HashTable中的静态内部类，在HashTable中的定义为：

private static class Entry<K,V> implements Map.Entry<K,V> {
	int hash;
	K key;
	V value;
	Entry<K,V> next;

	protected Entry(int hash, K key, V value, Entry<K,V> next) {
	    this.hash = hash;
	    this.key = key;
	    this.value = value;
	    this.next = next;
	}

	protected Object clone() {
	    return new Entry<K,V>(hash, key, value,
				  (next==null ? null : (Entry<K,V>) next.clone()));
	}

	public K getKey() {
	    return key;
	}

	public V getValue() {
	    return value;
	}

	public V setValue(V value) {
	    if (value == null)
		throw new NullPointerException();

	    V oldValue = this.value;
	    this.value = value;
	    return oldValue;
	}

	......
    }

    Entry中的四个变量的定义与HashMap中的一致，区别在于在hashMap中的key是final型的，定义了之后不允许修改 。

3.HashTable的初始化

    HashTable的初始化也有四种方法，但是与HashMap的初始化有所区别：

    （1）HashMap中默认初始化的容量大小是16，而在HashTable中默认容量是11；

    （2）在HashMap中数组的容量必须是2的次幂，即使定义的不是2的次幂，也会进行调整，保证必须是2的次幂，但是在HashTable中却无此规定；

    //初始化HashTable：指定容量和负载因子，这里与HashTable的区别是如果指定的容量是0的话，初始化容量为1，但是并不要求容量的大小一定是2的次幂
    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];
    	threshold = (int)(initialCapacity * loadFactor);
        }

       
        public Hashtable(int initialCapacity) {
    	this(initialCapacity, 0.75f);
        }

        //默认构造函数，指定的大小是11，HashMap的指定的大小是16
        public Hashtable() {
    	this(11, 0.75f);
        }

        //根据指定的map进行初始化
    	this(Math.max(2*t.size(), 11), 0.75f);
    	putAll(t);
        }

4.HashTable的put方法

    由于在HashTable中不允许null值的存在，在进行put操作时，

    （1）需要对null值进行检查，如果值为null，直接抛出空指针异常。

    （2）对key值进行判断是否在HashTable中已经存在，首先根据key值hashcode计算出key在table中的位置index，取出table[index]位置的链表，对链表进行遍历，如果key值已经存在，则用新的value值替换旧值，同时返回旧值，put操作结束。

     （3）如果key值不存在，首先根据table中的元素个数count和阈值threshold判断是否需要对数组进行扩容，如果需要调用rehash方法进行扩容，扩容完毕之后由于数组进行了变化，需要重新计算key在数组中的索引index

    （4）取得table[index]位置的链表，将新的元素插入带链表的表头，完成put操作。

    与HashMap中不同的是由于HashTable中不允许null值的存在是，所以在put操作时，不需要对key值进行额外的判断。

public synchronized V put(K key, V value) {
    	//判断value是否为空
    	if (value == null) {
    	    throw new NullPointerException();
    	}

    	//判断key是否已经存在
    	Entry tab[] = table;
    	int hash = key.hashCode();
    	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)) {
    		V old = e.value;
    		e.value = value;
    		return old;
    	    }
    	}

    	modCount++;
    	if (count >= threshold) {
    	    //如果需要扩容，调用rehash方法
    	    rehash();

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

    	//将元素插入到对应的位置
    	Entry<K,V> e = tab[index];
    	tab[index] = new Entry<K,V>(hash, key, value, e);
    	count++;
    	return null;
}

    从这段代码中可以看到HashTable的put操作与HashMap的put操作有所区别的，首先是计算key在table中的位置index的方法，HashMap中的index计算在上一篇文章中已经讲到过，主要是对key的hashcode二次计算，运用各种位运算的方法最终决定在table中的位置，但是在hashTable中使用的是模运算的方法，在上面的代码中（hash&0x7FFFFFFF)是将hash与Integer的最大值进行与运算，确保hash的值是在integer的范围内，然后对table的长度进行取模，得到key在table中的索引index。

    在put操作中，在插入元素之前会进行count和threshold的判断是否需要对HashTable进行rehash操作，也就是对table数组进行扩容，每次扩容的大小是数组的2倍+1，扩容操作的步骤与HashMap的类似，都是对旧的数组进行遍历，取出每个位置上的链表，然后对每个元素重新计算在新的数组中的位置，并将元素插入到相应的位置。

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

    	int newCapacity = oldCapacity * 2 + 1;
    	Entry[] newMap = new Entry[newCapacity];

    	modCount++;
    	threshold = (int)(newCapacity * loadFactor);
    	table = newMap;

    	for (int i = oldCapacity ; i-- > 0 ;) {
    	    for (Entry<K,V> old = oldMap[i] ; old != null ; ) {
    		Entry<K,V> e = old;
    		old = old.next;

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

5.HashTable的get操作

    HashTable中get操作取值也比较简单，首先根据key的hashcode计算在table中的索引index，然后取出在table中的链表，对链表进行遍历，得到对应的value值。

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

6.HashTable的contains方法

    在HashTable中的contains方法主要有三种，前两种是判断table中是否包含某个value值，第三个是判断table中是否包含某个key。

    contains(Object value)和containsValue(Object value)的实现步骤主要是：

    （1）判断value值是否为空，如果为空抛出空指针异常

    （2）从数组的尾部开始进行遍历，取出每个位置上的链表，遍历链表，判断元素值是否等于value，如果相等直接返回true

    判断value值存在时只要有一个值等于value值就认为是存在的。

    containsKey（Object key）判断key是否存在的步骤是：

    （1）根据key值计算在table中的索引位置index

    （2）取出对应索引位置的链表进行遍历，判断key值是否存在。

//判断HashTable中是否包含某值：
public synchronized boolean contains(Object value) {
    	if (value == null) {
    	    throw new NullPointerException();
    	}

    	Entry tab[] = table;
    	for (int i = tab.length ; i-- > 0 ;) {
    	    for (Entry<K,V> e = tab[i] ; e != null ; e = e.next) {
    		if (e.value.equals(value)) {
    		    return true;
    		}
    	    }
    	}
    	return false;
}
//判断HashTable中是否包含某值：
 public boolean containsValue(Object value) {
    	return contains(value);
}

//判断hashTable中是否包含某个key
public synchronized boolean containsKey(Object key) {
    	Entry tab[] = table;
    	int hash = key.hashCode();
    	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 true;
    	    }
    	}
    	return false;
 }

三、HashTable的遍历方式

1.通过Iterator遍历hashTable的键值对

根据entrySet()获得HashTable的键值对的set集合，然后通过Iterator迭代器进行遍历

Object key = null, value = null;
Iterator iter = table.entrySet().iterator();
while(iter.hasNext()) {
    Map.Entry entry = (Map.Entry)iter.next();
    key = entry.getKey();
    value = entry.getValue();
}

2.通过Iterattor遍历HashTable的键

根据keySet()得到HashTable中的key的集合，value值需要调用HashTable中的get方法获取

Object key = null, value = null;
Iterator iter = table.keySet().iterator();
while (iter.hasNext()) {
	key = iter.next();
	value = table.get(key);
}

3.根据Iterator遍历HashTable的值

这种方法只能得到HashTable中所有value的集合，首先是根据table.values()方法得到所有value值的集合，然后根据Iterator进行遍历。

Object value = null;
Collection c = table.values();
Iterator iter= c.iterator();
while (iter.hasNext()) {
	value = iter.next();
}

4.根据Enumeration遍历HashTable的键

    根据keys得到HashTable中所有key的集合，根据Enumeration进行遍历得到所有的key值

Enumeration enu = table.keys();
Object key = null;
while(enu.hasMoreElements()) {
	key = enu.nextElement();
} 

5.根据Enumeration遍历HashTable的值

    根据elements得到HashTable中所有的value的集合，根据Enumeration进行遍历得到所有的value值

Object value = null;
Enumeration enu = table.elements();
while(enu.hasMoreElements()) {
	value = enu.nextElement();
}

下面为5种遍历方法的测试：

public static void main(String[] args) {
	Hashtable<Integer, String> table = new Hashtable<Integer, String>();
	table.put(1, "aaa");
	table.put(2, "bbb");
	table.put(3, "ccc");
	table.put(4, "ddd");
	table.put(5, "eee");
		
	//第一种方法：Iterator遍历HashTable的键值对
	System.out.println("HashTable遍历第一种方法：entrySet:");
	Integer key1 = null;
	String value1 = null;
	Iterator iter1 = table.entrySet().iterator();
	while(iter1.hasNext()) {
	        Map.Entry entry = (Map.Entry)iter1.next();
		key1 = (Integer)entry.getKey();
		value1 = (String)entry.getValue();
		System.out.println("key="+key1+" value="+value1);
	}
		
	//第二种方法：Iterator遍历HashTable的key
	System.out.println("HashTable遍历第二种方法：keySet:");
	Integer key2 = null;
	String value2 = null;
	Iterator iter2 = table.keySet().iterator();
	while (iter2.hasNext()) {
		key2 = (Integer)iter2.next();
		value2 = (String)table.get(key2);
		System.out.println("key="+key2+" value="+value2);
	}
		
	//第三种方法：Iterator遍历HashTable的value
	System.out.println("HashTable遍历第三种方法：value");
	String value3 = null;
	Collection c = table.values();
	Iterator iter3= c.iterator();
	while (iter3.hasNext()) {
		value3 = (String)iter3.next();
		System.out.println("value="+value3);
	}
		
	System.out.println("HashTable遍历第四种方法：key");
	//第四种方法：Enumeration遍历Hashtable的键
	Enumeration enu4 = table.keys();
	while(enu4.hasMoreElements()) {
		System.out.println("key="+enu4.nextElement());
	}  
		
	//第五种方法：通过Enumeration遍历Hashtable的值
	System.out.println("HashTable遍历第五种方法：value");
	Enumeration enu5 = table.elements();
	while(enu5.hasMoreElements()) {
		System.out.println("value="+enu5.nextElement());
	}
}

四、HashMap与HashTable的区别

	HashMap	HHashTable
基类	基于AbstractMap	基于Dictionary
null值	允许存在一个null的key和任意个null值的value	key和value都不允许为空
线程安全	单线程安全	多线程安全
遍历	仅支持Iterator遍历方式	支持Iterator和Enumeration遍历方式
初始化	默认初始化容量为16	默认初始化容量为11
容量	必须是2的次幂，初始化不为2的次幂，也会调整为2的次幂	没有要求，但是是奇数
扩容	每次调整容量为之前容量的2倍	每次调整为之前容量的2倍+1
计算索引index方法	对key的hashcode再次进行位运算得到	对key的hashcode与数组容量进行取模运算得到