Collection HashTable
HashTable原理(数据结构等同于HashMap)
Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现。
Hashtable中的方法是同步的，而HashMap方法(在缺省情况下)是非同步的。
Hashtable 它的key、value都不可以为null。
一、HashTable类加载
无静态代码块，父类Dictionary也没有就不谈了
二、默认构造方法开始
public Hashtable() {
this(11, 0.75f);
}
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);
}
通过学习hashmap知道，这表示hashtable初始是11的大小，也是0.75的容量比例
table = new Entry<?,?>[initialCapacity]; 说明初始时已经构建了数据结构是Entry类型的数组，Entry源码和hashmap基本元素用的node基本是一样的
threshold= 11*0.75=8.25 即容量是8
threshold上限是MAX_ARRAY_SIZE + 1 Integer.MAX_VALUE - 8+1=Integer.MAX_VALUE -7 这个上限根据注释说明，是因为一些JVM的不同限制，为了防止OutOfMemoryError而进行-8的
三、put方法
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];
for(; entry != null ; entry = entry.next) {
if ((entry.hash == hash) && entry.key.equals(key)) {
V old = entry.value;
entry.value = value;
return old;
}
}
addEntry(hash, key, value, index);
return null;
}
1.synchronized 同步 还是方法级别的同步，因此效率可想肯定不是很高
2.value==null 抛错 说明值不能null
3.int index = (hash & 0x7FFFFFFF) % tab.length; 这个index的算法，看逼格就没hashmap高啊
3.1具体0x7FFFFFFF是2 31次幂，即01111111111111111111111111111111 安位与 随便一个与之后好像没变化啊，那这句是干嘛的呢，闲的？我们要相信大佬们不会闲的没事写废代码的
与的作用其实就是第一位0，为了干掉负的hash的，-1的hash值就是-1，再%，显然不能让出现这个情况
3.2 %tab.length就好说了，让索引落在table内，这种方式相比hashmap的二次hash再异或，效率肯定差一些的
4.for循环 只看这个循环就知道了，数据结构是数组加链表了
主要作用是找当前索引的链表上有没有相同key 又就覆盖值结束
5.addEntry(hash, key, value, index);当前索引没找到相同key，或者压根索引上就是空的，就在当前索引上加节点
四、addEntry增加节点方法
private void addEntry(int hash, K key, V value, int index) {
modCount++;
Entry<?,?> tab[] = table;
if (count >= threshold) {
// Rehash the table if the threshold is exceeded
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];
tab[index] = new Entry<>(hash, key, value, e);
count++;
}
1. modCount++;结构变更次数，不谈
2. if (count >= threshold) { 是否扩容的判断，也是一个主要地方了，看看扩容方案
2.1 rehash();
protected void rehash() {
int oldCapacity = table.length;
Entry<?,?>[] oldMap = table;
// overflow-conscious code
int newCapacity = (oldCapacity << 1) + 1; 说明扩容方案是 扩2倍+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;
}
}
}
2.2 完成扩容了，需要对本次要添加元素重新计算索引位置
3. Entry<K,V> e = (Entry<K,V>) tab[index];
tab[index] = new Entry<>(hash, key, value, e);
创建新元素把添加到数组。
这里有一个地方要注意到，再有值的情况下，hashmap是在链表末尾挂载新元素的，而这是在链表头也就是数组索引这个位置挂载新元素，一前一后要注意这点
五、其它一些
1.关于2n+1的扩展，在hashtable选择用取模的方式来进行，那么尽量使用素数、奇数会让结果更加均匀一些，具体证明，可以看看已经证明这点的技术文章
关于hash，hashmap用2的幂，主要是其还有一个hash过程即二次hash，不是直接用key的hashcode，这个过程打散了数据
总体就是一个减少hash冲突，并且找索引效率还要高，实现都是要考量这两因素的
六、hashtable已经算是废弃了
从实现上看，实际hashmap比hashtable改进良多，不管hash方案，还是结构上多红黑树，唯一缺点是非线程安全。
但是hashtable的线程安全机制效率是非常差的，现在能找到非常多的替代方案，比如Collections.synchronizedMap，courrenthashmap等
齊帥
