Java集合詳解（五）：Hashtable原理解析

概述

　　本文是基於jdk8_271版本進行分析的。
　　Hashtable與HashMap一樣，是一個儲存key-value的雙列集合。底層是基於陣列+連結串列實現的，沒有紅黑樹結構。Hashtable預設初始化容量為11，Hashtable也會動態擴容，與HashMap不同的是，每次擴容的容量是原容量2倍+1。Hashtable的key和value都不允許為null。Hashtable在方法上都加了synchronized同步鎖。所以Hashtable是執行緒安全的，同時Hashtable的效率也相對較低。

資料結構

• 實現繼承關係

public class Hashtable<K,V>
    extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable

1. Dictionary：
2. Map：
3. Cloneable：
4. Serializable：

• 成員變數

    // 存放hash表資料
    private transient Entry<?,?>[] table;

    // 元素數量
    private transient int count;

    // 閾值。元素數量達到該值，進行擴容
    private int threshold;

    // 載入因子，預設是0.75
    private float loadFactor;

    // 修改次數
    private transient int modCount = 0;

• 建構函式

　　Hashtable預設初始化容量為11，預設載入因子的值為0.75（與HashMap一樣）。選擇0.75作為預設的載入因子，完全是時間和空間成本上尋求的一種折中選擇。載入因子過高雖然減少了空間開銷，但同時也增加了查詢成本；載入因子過低雖然可以減少查詢時間成本，但是空間利用率很低。

　　Hashtable初始化容量值使用傳入的值（0除外），不會重新計算（HashMap需要重新計算，使得容量大小為2的指數次冪）。在構造方法建立物件時，會直接初始化陣列，沒有采用懶載入的方式。

    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);
        // 如果初始化容量傳入的是0，則預設使用1
        if (initialCapacity==0)
            initialCapacity = 1;
        this.loadFactor = loadFactor;
        table = new Entry<?,?>[initialCapacity];
        // 計算閾值。預計的閾值為初始化容量*載入因子，預計的閾值如果大於MAX_ARRAY_SIZE + 1，則實際閾值設定為MAX_ARRAY_SIZE + 1
        threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
    }

    public Hashtable(int initialCapacity) {
        // 傳入初始化容量，載入因子使用預設值0.75。初始化容量傳入的是多少就初始化多大（0除外；傳入的如果0，預設使用1），不需要再重新計算
        this(initialCapacity, 0.75f);
    }

    public Hashtable() {
        // 預設初始化容量11，預設載入因子0.75
        this(11, 0.75f);
    }

    public Hashtable(Map<? extends K, ? extends V> t) {
        // 初始化容量為傳入集合元素數量的2倍（至少為11），載入因子使用預設值0.75
        this(Math.max(2*t.size(), 11), 0.75f);
        putAll(t);
    }

主要方法解析

• 擴容方法

　　這裡與HashMap擴容時候有點區別，連結串列資料遷移時候，Hashtable是在連結串列頭部插入（和之前連結串列反過來），HashMap是在尾部插入。

    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++; // 修改次數+1
        // 計算閾值。新容量值*載入因子，與容量最大值+1，兩個比較取最小值
        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 ; ) {
                // 遍歷該索引位連結串列，這裡與jdk8中hashmap有點區別，這裡是在連結串列頭部插入（和之前連結串列會反過來），hashmap是在尾部插入
                Entry<K,V> e = old;
                old = old.next;

                int index = (e.hash & 0x7FFFFFFF) % newCapacity;
                e.next = (Entry<K,V>)newMap[index];
                newMap[index] = e;
            }
        }
    }

• 新增元素

　　新增元素時，Hashtable與HashMap有3點區別：

1. Hashtable的key-value都不允許為null。
2. Hashtable是在連結串列頭部插入（和之前連結串列反過來），HashMap是在尾部插入。
3. Hashtable是先判斷是否需要擴容，再插入元素；jdk8HashMap是先插入元素再判斷是否需要擴容。

    public synchronized V put(K key, V value) {
        // Make sure the value is not null
        if (value == null) {
            // value為空，會丟擲空指標異常
            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)) {
                // 該key已經存在，直接替換原值
                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;
        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++;
    }

• 刪除元素

    public synchronized V remove(Object key) {
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        Entry<K,V> e = (Entry<K,V>)tab[index];
        for(Entry<K,V> prev = null ; e != null ; prev = e, e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                modCount++;
                if (prev != null) {
                    prev.next = e.next;
                } else {
                    tab[index] = e.next;
                }
                count--;
                V oldValue = e.value;
                e.value = null;
                return oldValue;
            }
        }
        return null;
    }
    public synchronized boolean remove(Object key, Object value) {
        Objects.requireNonNull(value);

        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        Entry<K,V> e = (Entry<K,V>)tab[index];
        for (Entry<K,V> prev = null; e != null; prev = e, e = e.next) {
            if ((e.hash == hash) && e.key.equals(key) && e.value.equals(value)) {
                modCount++;
                if (prev != null) {
                    prev.next = e.next;
                } else {
                    tab[index] = e.next;
                }
                count--;
                e.value = null;
                return true;
            }
        }
        return false;
    }

• 序列化/反序列化方法

    private void writeObject(java.io.ObjectOutputStream s)
            throws IOException {
        Entry<Object, Object> entryStack = null;

        synchronized (this) {
            // Write out the threshold and loadFactor
            s.defaultWriteObject();

            // Write out the length and count of elements
            s.writeInt(table.length);
            s.writeInt(count);

            // Stack copies of the entries in the table
            for (int index = 0; index < table.length; index++) {
                Entry<?,?> entry = table[index];

                while (entry != null) {
                    entryStack =
                        new Entry<>(0, entry.key, entry.value, entryStack);
                    entry = entry.next;
                }
            }
        }

        // Write out the key/value objects from the stacked entries
        while (entryStack != null) {
            s.writeObject(entryStack.key);
            s.writeObject(entryStack.value);
            entryStack = entryStack.next;
        }
    }

    private void readObject(java.io.ObjectInputStream s)
         throws IOException, ClassNotFoundException
    {
        // Read in the threshold and loadFactor
        s.defaultReadObject();

        // Validate loadFactor (ignore threshold - it will be re-computed)
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new StreamCorruptedException("Illegal Load: " + loadFactor);

        // Read the original length of the array and number of elements
        int origlength = s.readInt();
        int elements = s.readInt();

        // Validate # of elements
        if (elements < 0)
            throw new StreamCorruptedException("Illegal # of Elements: " + elements);

        // Clamp original length to be more than elements / loadFactor
        // (this is the invariant enforced with auto-growth)
        origlength = Math.max(origlength, (int)(elements / loadFactor) + 1);

        // Compute new length with a bit of room 5% + 3 to grow but
        // no larger than the clamped original length.  Make the length
        // odd if it's large enough, this helps distribute the entries.
        // Guard against the length ending up zero, that's not valid.
        int length = (int)((elements + elements / 20) / loadFactor) + 3;
        if (length > elements && (length & 1) == 0)
            length--;
        length = Math.min(length, origlength);

        if (length < 0) { // overflow
            length = origlength;
        }

        // Check Map.Entry[].class since it's the nearest public type to
        // what we're actually creating.
        SharedSecrets.getJavaOISAccess().checkArray(s, Map.Entry[].class, length);
        table = new Entry<?,?>[length];
        threshold = (int)Math.min(length * loadFactor, MAX_ARRAY_SIZE + 1);
        count = 0;

        // Read the number of elements and then all the key/value objects
        for (; elements > 0; elements--) {
            @SuppressWarnings("unchecked")
                K key = (K)s.readObject();
            @SuppressWarnings("unchecked")
                V value = (V)s.readObject();
            // sync is eliminated for performance
            reconstitutionPut(table, key, value);
        }
    }

 

Dictionary