java8 HashTable 原理

HashTable原理

Hashtable是基於陳舊的Dictionary類的，HashMap是Java 1.2引進的Map接口的一個實現。
Hashtable中的方法是同步的，而HashMap方法(在缺省狀況下)是非同步的。

HashMap原理：http://www.cnblogs.com/zhaojj/p/7805376.html

 

基於jdk1.8

 

1、HashTable類加載
無靜態代碼塊，父類Dictionary也沒有就不談了

 

 

2、默認構造方法開始

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的

 

 3、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，或者壓根索引上就是空的，就在當前索引上加節點

 

 

4、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是在鏈表末尾掛載新元素的，而這是在鏈表頭也就是數組索引這個位置掛載新元素，一前一後要注意這點

 

 

5、其它一些
1.關於2n+1的擴展，在hashtable選擇用取模的方式來進行，那麼儘可能使用素數、奇數會讓結果更加均勻一些，具體證實，能夠看看已經證實這點的技術文章
關於hash，hashmap用2的冪，主要是其還有一個hash過程即二次hash，不是直接用key的hashcode，這個過程打散了數據
整體就是一個減小hash衝突，而且找索引效率還要高，實現都是要考量這兩因素的

6、hashtable已經算是廢棄了
從實現上看，實際hashmap比hashtable改進良多，無論hash方案，仍是結構上多紅黑樹，惟一缺點是非線程安全。
可是hashtable的線程安全機制效率是很是差的，如今能找到很是多的替代方案，好比Collections.synchronizedMap，courrenthashmap等