【jdk源码解析三】java.util.Hashtable

HashMap是Hashtable的非线程安全版。非常明显由源码可以看出，Hashtable与HashMap并不出于同一个人之手，代码风格有很大差别。

首先，Hashtable继承自Dictionary接口而不是Map接口，为什么呢？Dictionary接口其实与Map接口差不多，但是已经被废弃，被Map接口所取代。与HashMap相同，Hashtable也实现了java.lang.Cloneable接口与java.io.Serializable接口。

数据结构上，Hashtable与HashMap的结构是几乎一样的实现。

那么Hashtable在源码大体结构与HashMap相似的情况下，有哪些区别呢？首先，Hashtable是线程安全的，其大多数方法是synchronized()的，当然构造方法除外（构造器不能用abstract,final,static,synchronized及native来修饰只能是public,protected,private）。

其次，Hashtable的初始默认桶容量为11,默认装载因子为0.75，而HashMap则是16和0.75。

然后，Hashtable的索引计算方法与HashMap完全不同，实际上，HashMap会使用一个非常好用的哈希函数来对键的hashCode做哈希，然后将其映射到Entry数组的对应位置，而Hashtable则将键值的hashCode直接与0x7fffffff直接相与，然后模数组的长度，这里就可以看出，由于Hashtable是早期版本，因此，并没有想出像HashMap那样，使用桶容量必须是2的幂次以及相应的求数组索引的方法的一系列优化措施，因此，这里的模运算不能不说是一个非常耗时的操作，相比HashMap的实现，就没有那么精妙。

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采用的也是倍增的方式来实现的扩容，由于其没有桶容量必须是2的幂次的要求，因此，其扩容时实际上是采用2倍加1的方式来扩容。

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

关于Hashtable,还有一点，Hashtable实现了map自己的hashCode。这个函数应该是神来之笔，因为其实现是很巧妙的。

public synchronized int hashCode() {
        /*
         * This code detects the recursion caused by computing the hash code
         * of a self-referential hash table and prevents the stack overflow
         * that would otherwise result.  This allows certain 1.1-era
         * applets with self-referential hash tables to work.  This code
         * abuses the loadFactor field to do double-duty as a hashCode
         * in progress flag, so as not to worsen the space performance.
         * A negative load factor indicates that hash code computation is
         * in progress.
         */
        int h = 0;
        if (count == 0 || loadFactor < 0)
            return h;  // Returns zero

        loadFactor = -loadFactor;  // Mark hashCode computation in progress
        Entry[] tab = table;
        for (int i = 0; i < tab.length; i++)
            for (Entry e = tab[i]; e != null; e = e.next)
                h += e.key.hashCode() ^ e.value.hashCode();
        loadFactor = -loadFactor;  // Mark hashCode computation complete

	return h;
    }

为什么会要用到loadFactor？每次计算为什么要先乘个-1？我没有想明白，但是在stackoverflow上问了这个问题之后，得到了大神的帮助。由于有可能键值对存在类似于<"key1",this>这样的方式，如果不加控制的话，会造成死循环的调用hashCode，因此，需要使用loadFactor作为标志，如果调用时小于0，说明进入了死循环，直接就返回0。神作啊！详情移步http://stackoverflow.com/questions/21085135/how-to-understand-the-hashcode-funtion-of-java-util-hashtable-in-the-source-code

另，HashMap中并没有看到对于hashCode的实现。