一、继承关系
public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, java.io.Serializable
Hashtable继承Dictionary抽象类,实现Map接口,支持克隆,支持序列化
二、基本属性
private transient Entry<K,V>[] table;//被transient关键字修饰的Entry类型数组
private transient int count;//存放Entry类节点的有效个数
private int threshold;//扩容的阈值
private float loadFactor;//加载因子
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;//数组可存放的最大容量
三、Entry类
private static class Entry<K,V> implements Map.Entry<K,V> {
int hash;
final 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;
}
}
Hashtable采用哈希表的存储结构,用链地址法来解决哈希冲突
四、构造函数
1.无参构造
public Hashtable() {
//默认初始容量为11,默认加载因子0.75
this(11, 0.75f);
}
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;
//Hashtable的初始化在构造函数中
table = new Entry[initialCapacity];
threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
initHashSeedAsNeeded(initialCapacity);
}
②指定数组容量,加载因子默认0.75
public Hashtable(int initialCapacity) {
this(initialCapacity, 0.75f);
}
③通过Map集合实例构造HashTable
public Hashtable(Map<? extends K, ? extends V> t) {
this(Math.max(2*t.size(), 11), 0.75f);
putAll(t);
}
五、常用方法
1.put(key,value)
public synchronized V put(K key, V value) {
//若value为null值,抛出空指针异常
if (value == null) {
throw new NullPointerException();
}
Entry tab[] = table;
int hash = hash(key);
//获取hash在数组中的下标
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)) {
//若已存在key值用value覆盖
V old = e.value;
e.value = value;
return old;
}
}
modCount++;
/**
* 数组进行扩容的条件:
* 数组有效个数>=阈值,即count >= threshold
*/
if (count >= threshold) {
rehash();
//更新属性
tab = table;
hash = hash(key);
index = (hash & 0x7FFFFFFF) % tab.length;
}
//若不存在相同的key,则直接创建新节点
Entry<K,V> e = tab[index];
tab[index] = new Entry<>(hash, key, value, e);
count++;
return null;
}
- rehash()操作分析
protected void rehash() {
int oldCapacity = table.length;
Entry<K,V>[] oldMap = table;
//对数组进行(2*table.length+1)倍扩容
int newCapacity = (oldCapacity << 1) + 1;
//对newCapacity的合法性进行校验
if (newCapacity - MAX_ARRAY_SIZE > 0) {
if (oldCapacity == MAX_ARRAY_SIZE)
return;
newCapacity = MAX_ARRAY_SIZE;
}
Entry<K,V>[] newMap = new Entry[newCapacity];
modCount++;
//更新threshold阈值
threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
boolean rehash = initHashSeedAsNeeded(newCapacity);
table = newMap;
//两层for循环.外层从后向前遍历数组,内层遍历链表元素
for (int i = oldCapacity ; i-- > 0 ;) {
for (Entry<K,V> old = oldMap[i] ; old != null ; ) {
Entry<K,V> e = old;
old = old.next;
if (rehash) {
e.hash = hash(e.key);
}
//对每个元素进行重新计算在新数组中的位置
int index = (e.hash & 0x7FFFFFFF) % newCapacity;
e.next = newMap[index];
newMap[index] = e;
}
}
}
2.get(key)
public synchronized V get(Object key) {
Entry tab[] = table;
int hash = hash(key);
int index = (hash & 0x7FFFFFFF) % tab.length;
//通过key确定元素在数组中的下标
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;
}
3.remove(key)
public synchronized V remove(Object key) {
Entry tab[] = table;
int hash = hash(key);
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<K,V> e = tab[index], 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;
}