HashTable源码解析
我们首先从构造方法看起
HashTable的构造方法
/**
*这是空构造方法实际调用的是下面的带参的构造方法
*/
public Hashtable() {
this(11, 0.75f);
}
/**
*带参构造方法
*/
public Hashtable(int initialCapacity, float loadFactor) {
//容器初始化的大小检查,小于 0 抛出不合法的参数异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
//加载因子必须大于0
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal Load: "+loadFactor);
//如果初始化容器大小等于0,就将其赋值为1
if (initialCapacity==0)
initialCapacity = 1;
//加载因此是0.75
this.loadFactor = loadFactor;
//创建一个 initialCapacity 大小的Entry键值对数组,将值赋给HashTable的一个属性 table,我们看一下Entry这个类(下一个小结)
table = new Entry<?,?>[initialCapacity];
threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
}
Entry类
private static class Entry<K,V> implements Map.Entry<K,V> {
final 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底层是使用了数据+链表实现,如下图数据结构
HashTable的Put方法
我看下面的源代码
//这里的 K 和 V 就是我们传入的key和value键值对,就是泛型参数,该方法是由synchronize修饰的,
//因此是线程安全的
public synchronized V put(K key, V value) {
//这里不予许value值为空 key可以为空
if (value == null) {
throw new NullPointerException();
}
Entry<?,?> tab[] = table;
int hash = key.hashCode();
//计算key在数组table中的下标位置
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
//根据计算的下标拿到当前数组中对应下标的元素
Entry<K,V> entry = (Entry<K,V>)tab[index];
//遍历改下标的链表
for(; entry != null ; entry = entry.next) {
//判断要加入的键值对是否已经存在链表中
if ((entry.hash == hash) && entry.key.equals(key)) {
//存在就替换旧的value
V old = entry.value;
entry.value = value;
//返回旧的值
return old;
}
}
//不存在就调用这个方法
addEntry(hash, key, value, index);
return null;
}
//我们进入这个方法
private void addEntry(int hash, K key, V value, int index) {
modCount++;
Entry<?,?> tab[] = table;
//判断当前整个HashTable中元素的个数是否已经超过数组长度的75%
if (count >= threshold) {
// Rehash the table if the threshold is exceeded
//进行扩容
//我们看看下面的rehash函数
rehash();
tab = table;
hash = key.hashCode();
index = (hash & 0x7FFFFFFF) % tab.length;
}
// Creates the new entry.
@SuppressWarnings("unchecked")
//获得当前链表的头指针
Entry<K,V> e = (Entry<K,V>) tab[index];
//新创建的Entry的next属性指向e
//并将Entry的值赋给数组下标对应的元素
//也就是使用头插法的方式存入Entry
tab[index] = new Entry<>(hash, key, value, e);
count++;
}
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;
}
}
}
根据源码我们可以总结如下:
1、HashTable初始化的容器大小为1
2、底层用数组+链表来实现
3、当元素的总数到达数组长度的75%就会扩容,新容量 = 旧容量*2+1
4、方法使用的是synchronized关键字修饰,所以是线程安全的