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等

java8 HashTable 原理