1.HashTable的类声明
public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, java.io.Serializable
继承的是Dictionary类,实现了Map、Cloneable、Serializable。
注意:这也是Hashtable和HashMap第一个不同的地方,HashMap实现的是AbstractMap类。
2. HashTable的成员变量
1)private transient Entry< ?,? >[] table;//用来实现Hashtable所借助的数组,默认大小为11。
注意:这是Hashtable与HashMap第二个不同的地方,Hashtable的默认容量大小为11,HashMap的默认容量大小为16且扩容的大小必须一直是2的幂次方。
2)、private transient int count;//用来记录table数组中存储元素的个数
3)、private int threshold;//扩容的门限,即如果数组table中存储的元素个数大于threshold,则扩大数组table的大小
4)、private float loadFactor;//加载因子,默认值为0.75f,扩容门线threshold的值等于loadFactor与数组table的容量的乘积.
3. HashTable的构造方法
/*
*我们获得的hashtable对象,无论有参数,无参数的 最终都调用的这个构造
*initialCapacity为初始容量,默认大小为 11
*loadFactor为加载因子,默认大小为0.75f,好比是你的内容超过了 总长度了75%,就会自动扩容
*/
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)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
}
4.HashMap的重要方法
1.put方法
put方法存储数据的思想如下:首先根据拿到key的hashcode,然后根据hashCode找到此元素即将要存储的位置index.如果位置index已经有元素链表了,则在此链表中,寻找是否有key已经存在了,如果存在,则更新value值,如果不存在,则将此value存储在index位置上。
从源码中可以看到,put方法首先检查value是否为null,如果为空,则抛异常。
注意:这也是Hashtable与HashMap的另一个不同点,在HashMap中,null可以作为键,这样的键只有一个;可以有一个或多个键所对应的值为null。
另一个区别,在Hashtable中所有的方法都是用synchronized关键字进行了同步,而HashMap中的方法在缺省情况下是非同步的。在多线程并发的环境下,可以直接使用Hashtable,但是要使用HashMap的话就要自己增加同步处理了。
还有区别就是HashMap的teble有可能是treenode结构有可能是列表,而HashTable都是对象列表,所以HashTable处理的相对简单。
public synchronized V put(K key, V value) {
// Make sure the value is not null
if (value == null) {
throw new NullPointerException();
}
// Makes sure the key is not already in the hashtable.
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
Entry<K,V> entry = (Entry<K,V>)tab[index];
//如果数组table中有值,则检查下是否有此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;
}
}
//如果没有此key,则添加此节点
addEntry(hash, key, value, index);
return null;
}
addEntry方法
思想如下:首先检查下数组table存储的元素个数是否大于扩容门限threshold.如果大于,则扩容,扩容之后,重新获取key的hashcode,并根据hashcode重新计算要存储的位置index.最后将要存储的数据存储到table[index]中。这里要注意的一点是,如果table[index]中已经有其它元素了,那么在同一个位子上的元素将以链表的形式存放,新加入的放在链头,最先加入的放在链尾。
private void addEntry(int hash, K key, V value, int index) {
modCount++;
Entry<?,?> tab[] = table;
//检查数组table中存储的数据个数>=门限,如果大于等于,则对数组进行扩容
if (count >= threshold) {
// Rehash the table if the threshold is exceeded
rehash();
//扩容之后,对key的hashcode、以及即将要存储的位置index重新进行更新
tab = table;
hash = key.hashCode();
index = (hash & 0x7FFFFFFF) % tab.length;
}
// Creates the new entry.
@SuppressWarnings("unchecked")
//获取table数组在index的元素,如果非空,则新节点放在这个节点的前面,成为新的链表头
Entry<K,V> e = (Entry<K,V>) tab[index];
tab[index] = new Entry<>(hash, key, value, e);
count++;
}
2、refresh方法
rehash方法的实现思想如下:首先对原来的长度乘以2+1就为即将扩容的长度。然后新建一个newCapacity的数组,将原来的table数组的元素拷贝到新的数组中去即可。
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
@SuppressWarnings("unchecked")
protected void rehash() {
int oldCapacity = table.length;
Entry<?,?>[] oldMap = table;
// overflow-conscious code
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;
}
Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];
modCount++;
threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
table = newMap;
for (int i = oldCapacity ; i-- > 0 ;) {
for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
Entry<K,V> e = old;
old = old.next;
int index = (e.hash & 0x7FFFFFFF) % newCapacity;
e.next = (Entry<K,V>)newMap[index];
newMap[index] = e;
}
}
}
3、get方法
get方法的思想也比较简单,如下:首先获取key的hashcode,然后根据hashcode得到存储位置index,最后在table[index]取出元素即可,不过要注意的是,这里可能存储了多个元素构成了一个链表,因此要进行一个key和hash的判断。
@SuppressWarnings("unchecked")
public synchronized V get(Object key) {
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
return (V)e.value;
}
}
return null;
}
**HashMap和Hashtable的几点区别**
1、继承类不一样
HashMap继承的是AbstractMap,Hashtable继承的是Dictionary。实现的接口一致(Map、Cloneable和Serializable)
2、初始容量不一样
HashMap默认容量为16,且容量只能是2的幂次方;Hashtable默认容量为11,容量并没有2的幂次方的限制,增加的方式是 oldCap*2+1。
3、HashMap是线程不安全的,Hashtable是线程安全的
默认情况下,HashMap类中的方法并没有进行同步,而Hashtable中的方法均使用synchronized进行了同步。因此,在多线程并发时,Hashtable可以直接使用,HashMap需要我们加入额外的同步操作。
4、使用的hashcode不一样
Hashtable是直接使用的key的hashcode(key.hashcode())。而HashMap的key的hashcode是另外计算的。hashMap 独立了hash算法,并且算法是通过key value 多次算出来的,减少了重复性
5、HashMap允许有一个key为null,多个value为null。而Hashtable不允许key和value为null。
6、HashMap和Hashtable内部遍历方式的实现不一样
Hashtable、HashMap都使用了 Iterator。而由于历史原因,Hashtable还使用了Enumeration的方式 。