Hashtable的实现原理

【IT168 技术文档】在仔细分析源代码之前，我们来看看Hashtable提供的一些接口方法。

public int size();

public boolean isEmpty() ;

public synchronized Enumeration keys();

public synchronized Enumeration elements();

public synchronized boolean contains(Object
value) ;

public synchronized boolean containsKey(Object
key);

public synchronized Object get(Object key);

public synchronized Object put(Object key, Object value) ;

public synchronized Object remove(Object key);

public synchronized void clear()
;

public synchronized void clear()
;

　　上面的方法我就不一一介绍了，具体的用法也是很简单，相对大家对此也比较熟悉了。

Hashtable的用法

Hashtable 有2个构造函数

public Hashtable(int initialCapacity); //指定容量大小

public Hashtable() {

this(11); //默认的容量是11，为什么是11，而不是10呢？

}

Demo1

Hashtable sTable = new Hashtable();

sTable.put("wuhua","wuhua");

sTable.remove("wuhua");

sTable.clear();

上面是简单的用法。

Hashtable源代码解读

　　在了解源代码之前，我们先来了解下一些java不常用的关键字。

transient

　　当串行化某个对象时，如果该对象的某个变量是transient，那么这个变量不会被串行化进去。也就是说，假设某个类的成员变量是transient，那么当通过ObjectOutputStream把这个类的某个实例保存到磁盘上时，实际上transient变量的值是不会保存的。因为当从磁盘中读出这个对象的时候，对象的该变量会没有被赋值。 另外这篇文章还提到，当从磁盘中读出某个类的实例时，实际上并不会执行这个类的构造函数，而是读取这个类的实例的状态，并且把这个状态付给这个类的对象。

引用地址：http://blog.chinaunix.net/u/22516/showart.php?id=380029

　　Transient 这个关键字很重要，来看下源代码里面有几处是用到这个关键字的。

private transient HashtableEntry table[];

private transient int count;

　　源代码中只有上面两个字段的定义是用到的，但是这两个字段是用于存储Hashtable的容器字段，因此可以说Hashtable是不允许序列化的。

内部类

　　Hashtable有2个内部类

　　HashtableEntry -- 用于存放key-value，nextElement的类。

class HashtableEntry {

int hash;

Object key;

Object value;

HashtableEntry next;

}

　　HashtableEnumerator 遍历的枚举类。

class HashtableEnumerator implements Enumeration {

boolean keys;

int index;

HashtableEntry table[];

HashtableEntry entry;

HashtableEnumerator(HashtableEntry table[], boolean keys) {

this.table = table;

this.keys = keys;

this.index = table.length;

}

public boolean hasMoreElements() {

if (entry != null)
{

return true;

}

while (index-- > 0)
{

if ((entry = table[index]) != null)
{

return true;

}

}

return false;

}

public Object nextElement() {

if (entry == null)
{

while ((index-- > 0) && ((entry = table[index]) == null));

}

if (entry != null)
{

HashtableEntry e = entry;

entry = e.next;

return keys ? e.key : e.value;

}

throw new NoSuchElementException(

/* #ifdef VERBOSE_EXCEPTIONS */

/// skipped "HashtableEnumerator"

/* #endif */

);

}

}

　　代码写的是相当的简介。有一些比较技巧性的用法也是相当的不错，比如：

if (entry == null) {

while ((index-- > 0) && ((entry = table[index]) == null));

} 这段写的是相当的好，可见作者的功力，循环变量table

while (index-- > 0)

//循环变量，查看是否有下一个元素，

if ((entry = table[index]) != null)
{

return true;

}

}

　　了解了Hashtable的数据存放格式，我们看看存放的关键逻辑

在put，remove，get方法中存在。

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

这样的函数，这个函数的意义上，根据散列值来获取对象的存储位置。

来欣赏下代码片段：

public synchronized Object get(Object key) {

HashtableEntry tab[] = table;

int hash = key.hashCode();

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

for (HashtableEntry e = tab[index] ; e != null ;
e = e.next) {

if ((e.hash == hash) && e.key.equals(key))
{

return e.value;

}

}

return null;

}

从上面的代码可以分析出。首先获取key的散列值，并且根据散列值进行key的Index定位

这里存在同一个index多个HashtableEntry 存在，所以才会有了next的变量，next就是存放相同位置不同key的实体。

下面再来看看Hashtable里面一个扩充容器的算法。

protected void rehash() {

int oldCapacity = table.length;

HashtableEntry oldTable[] = table;

int newCapacity = oldCapacity * 2 + 1;

HashtableEntry newTable[] = new HashtableEntry[newCapacity];

threshold = (int)((newCapacity * loadFactorPercent) / 100);

table = newTable;

for (int i = oldCapacity
; i-- > 0 ;) {

//循环遍历oldTable的对应的实体，并且遍历对应的实体的没一个对象，进行

//重新分配index，再进行保存

for (HashtableEntry old = oldTable[i] ; old != null ;
) {

HashtableEntry e = old;

old = old.next;

int index = (e.hash & 0x7FFFFFFF) % newCapacity;

e.next = newTable[index]; //e 的next 指向当前索引

newTable[index] = e; //

}

}

}

for (HashtableEntry old = oldTable[i] ; old != null ;
)

这段的用法很奇怪，我以前没有使用过，上面的代码等同于

HashtableEntry old = oldTable[i];

Whild(old != null){

...............................

...............................

}

不过个人比较习惯使用第2种方式