java8 HashTable 原理
HashTable原理
Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现。
Hashtable中的方法是同步的，而HashMap方法(在缺省情况下)是非同步的。
HashMap原理：http://www.cnblogs.com/zhaojj/p/7805376.html
基于jdk1.8
一、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等
