Hashtable 的實現原理

概述

和 HashMap 一樣，Hashtable 也是一個散列表，它儲存的內容是鍵值對。

Hashtable 在 Java 中的定義為：

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

從原始碼中，我們可以看出，Hashtable 繼承於 Dictionary 類，實現了 Map, Cloneable, java.io.Serializable介面。其中Dictionary類是任何可將鍵對映到相應值的類（如 Hashtable）的抽象父類，每個鍵和值都是物件（原始碼註釋為：The Dictionary

 class is the abstract parent of any class, such as Hashtable, which maps keys to values. Every key and every value is an object.）。但在這一點我開始有點懷疑，因為我查看了HashMap以及TreeMap的原始碼，都沒有繼承於這個類。不過當我看到註釋中的解釋也就明白了，其 Dictionary 原始碼註釋是這樣的：NOTE: This class is obsolete. New implementations should implement the Map interface, rather than extending this class. 該話指出 Dictionary 這個類過時了，新的實現類應該實現Map介面。

Hashtable 原始碼解讀

成員變數

Hashtable是通過"拉鍊法"實現的雜湊表。它包括幾個重要的成員變數：table, count, threshold, loadFactor, modCount。

• table是一個 Entry[] 陣列型別，而 Entry（在 HashMap 中有講解過）實際上就是一個單向連結串列。雜湊表的"key-value鍵值對"都是儲存在Entry陣列中的。
• count 是 Hashtable 的大小，它是 Hashtable 儲存的鍵值對的數量。
• threshold 是 Hashtable 的閾值，用於判斷是否需要調整 Hashtable 的容量。threshold 的值="容量*載入因子"。
• loadFactor 就是載入因子。
• modCount 是用來實現 fail-fast 機制的。

關於變數的解釋在原始碼註釋中都有，最好還是應該看英文註釋。

/**
     * The hash table data.
     */
    private transient Entry<K,V>[] table;

    /**
     * The total number of entries in the hash table.
     */
    private transient int count;

    /**
     * The table is rehashed when its size exceeds this threshold.  (The
     * value of this field is (int)(capacity * loadFactor).)
     *
     * @serial
     */
    private int threshold;

    /**
     * The load factor for the hashtable.
     *
     * @serial
     */
    private float loadFactor;

    /**
     * The number of times this Hashtable has been structurally modified
     * Structural modifications are those that change the number of entries in
     * the Hashtable or otherwise modify its internal structure (e.g.,
     * rehash).  This field is used to make iterators on Collection-views of
     * the Hashtable fail-fast.  (See ConcurrentModificationException).
     */
    private transient int modCount = 0;

構造方法

Hashtable 一共提供了 4 個構造方法：

• public Hashtable(int initialCapacity, float loadFactor)： 用指定初始容量和指定載入因子構造一個新的空雜湊表。useAltHashing 為 boolean，其如果為真，則執行另一雜湊的字串鍵，以減少由於弱雜湊計算導致的雜湊衝突的發生。
• public Hashtable(int initialCapacity)：用指定初始容量和預設的載入因子 (0.75) 構造一個新的空雜湊表。
• public Hashtable()：預設建構函式，容量為 11，載入因子為 0.75。
• public Hashtable(Map<? extends K, ? extends V> t)：構造一個與給定的 Map 具有相同對映關係的新雜湊表。

/**
     * Constructs a new, empty hashtable with the specified initial
     * capacity and the specified load factor.
     *
     * @param      initialCapacity   the initial capacity of the hashtable.
     * @param      loadFactor        the load factor of the hashtable.
     * @exception  IllegalArgumentException  if the initial capacity is less
     *             than zero, or if the load factor is nonpositive.
     */
    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);
        useAltHashing = sun.misc.VM.isBooted() &&
                (initialCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
    }

    /**
     * Constructs a new, empty hashtable with the specified initial capacity
     * and default load factor (0.75).
     *
     * @param     initialCapacity   the initial capacity of the hashtable.
     * @exception IllegalArgumentException if the initial capacity is less
     *              than zero.
     */
    public Hashtable(int initialCapacity) {
        this(initialCapacity, 0.75f);
    }

    /**
     * Constructs a new, empty hashtable with a default initial capacity (11)
     * and load factor (0.75).
     */
    public Hashtable() {
        this(11, 0.75f);
    }

    /**
     * Constructs a new hashtable with the same mappings as the given
     * Map.  The hashtable is created with an initial capacity sufficient to
     * hold the mappings in the given Map and a default load factor (0.75).
     *
     * @param t the map whose mappings are to be placed in this map.
     * @throws NullPointerException if the specified map is null.
     * @since   1.2
     */
    public Hashtable(Map<? extends K, ? extends V> t) {
        this(Math.max(2*t.size(), 11), 0.75f);
        putAll(t);
    }

put 方法

put 方法的整個流程為：

1. 判斷 value 是否為空，為空則丟擲異常；
2. 計算 key 的 hash 值，並根據 hash 值獲得 key 在 table 陣列中的位置 index，如果 table[index] 元素不為空，則進行迭代，如果遇到相同的 key，則直接替換，並返回舊 value；
3. 否則，我們可以將其插入到 table[index] 位置。

我在下面的程式碼中也進行了一些註釋：

public synchronized V put(K key, V value) {
        // Make sure the value is not null確保value不為null
        if (value == null) {
            throw new NullPointerException();
        }

        // Makes sure the key is not already in the hashtable.
        //確保key不在hashtable中
        //首先，通過hash方法計算key的雜湊值，並計算得出index值，確定其在table[]中的位置
        //其次，迭代index索引位置的連結串列，如果該位置處的連結串列存在相同的key，則替換value，返回舊的value
        Entry tab[] = table;
        int hash = hash(key);
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                V old = e.value;
                e.value = value;
                return old;
            }
        }

        modCount++;
        if (count >= threshold) {
            // Rehash the table if the threshold is exceeded
            //如果超過閥值，就進行rehash操作
            rehash();

            tab = table;
            hash = hash(key);
            index = (hash & 0x7FFFFFFF) % tab.length;
        }

        // Creates the new entry.
        //將值插入，返回的為null
        Entry<K,V> e = tab[index];
        // 建立新的Entry節點，並將新的Entry插入Hashtable的index位置，並設定e為新的Entry的下一個元素
        tab[index] = new Entry<>(hash, key, value, e);
        count++;
        return null;
    }

通過一個實際的例子來演示一下這個過程：

假設我們現在Hashtable的容量為5，已經存在了(5,5)，(13,13)，(16,16)，(17,17)，(21,21)這 5 個鍵值對，目前他們在Hashtable中的位置如下：

現在，我們插入一個新的鍵值對，put(16,22)，假設key=16的索引為1.但現在索引1的位置有兩個Entry了，所以程式會對連結串列進行迭代。迭代的過程中，發現其中有一個Entry的key和我們要插入的鍵值對的key相同，所以現在會做的工作就是將newValue=22替換oldValue=16，然後返回oldValue=16.

然後我們現在再插入一個，put(33,33)，key=33的索引為3，並且在連結串列中也不存在key=33的Entry，所以將該節點插入連結串列的第一個位置。

get 方法

相比較於 put 方法，get 方法則簡單很多。其過程就是首先通過 hash()方法求得 key 的雜湊值，然後根據 hash 值得到 index 索引（上述兩步所用的演算法與 put 方法都相同）。然後迭代連結串列，返回匹配的 key 的對應的 value；找不到則返回 null。

public synchronized V get(Object key) {
        Entry tab[] = table;
        int hash = hash(key);
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                return e.value;
            }
        }
        return null;
    }

Hashtable 遍歷方式

Hashtable 有多種遍歷方式：

//1、使用keys()
Enumeration<String> en1 = table.keys();
    while(en1.hasMoreElements()) {
    en1.nextElement();
}

//2、使用elements()
Enumeration<String> en2 = table.elements();
    while(en2.hasMoreElements()) {
    en2.nextElement();
}

//3、使用keySet()
Iterator<String> it1 = table.keySet().iterator();
    while(it1.hasNext()) {
    it1.next();
}

//4、使用entrySet()
Iterator<Entry<String, String>> it2 = table.entrySet().iterator();
    while(it2.hasNext()) {
    it2.next();
}

Hashtable 與 HashMap 的簡單比較

1. HashTable 基於 Dictionary 類，而 HashMap 是基於 AbstractMap。Dictionary 是任何可將鍵對映到相應值的類的抽象父類，而 AbstractMap 是基於 Map 介面的實現，它以最大限度地減少實現此介面所需的工作。
2. HashMap 的 key 和 value 都允許為 null，而 Hashtable 的 key 和 value 都不允許為 null。HashMap 遇到 key 為 null 的時候，呼叫 putForNullKey 方法進行處理，而對 value 沒有處理；Hashtable遇到 null，直接返回 NullPointerException。
3. Hashtable 方法是同步，而HashMap則不是。我們可以看一下原始碼，Hashtable 中的幾乎所有的 public 的方法都是 synchronized 的，而有些方法也是在內部通過 synchronized 程式碼塊來實現。所以有人一般都建議如果是涉及到多執行緒同步時採用 HashTable，沒有涉及就採用 HashMap，但是在 Collections 類中存在一個靜態方法：synchronizedMap()，該方法建立了一個執行緒安全的 Map 物件，並把它作為一個封裝的物件來返回。