java集合框架（二）：HashTable

時間 2019-11-07

標籤 java 集合框架 hashtable 欄目 Java 简体版

原文原文鏈接

HashTable做爲集合框架中的一員，如今是不多使用了，通常都是在面試中會問到其與HashMap的區別。爲了能在求職的時候用上場，咱們有必要對其原理進行解讀。javascript

HashTable的實現原理跟HashMap相似，也是經過節點的哈希值映射到哈希桶數組，若是發生哈希碰撞就構建一條鏈表，簡單點說就是：數組+鏈表java

1、類的定義

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

從以上的定義中，能夠發現其繼承自Dictionary，而HashMap是繼承自AbstractMap。Dictionary是一個字典類，內部定義了一些抽象方法，如今官方也不建議使用了。個人理解也是用來保存key-value的，不過要求key和value都不能爲空。面試

2、存儲單元

基本存儲單元：數組

private static class Entry<K,V> implements Map.Entry<K,V> {
        final int hash; // key算出的哈希值
        final K key; 
        V value;
        Entry<K,V> next; // 若是有鏈表的話指向下一個節點
}

哈希桶數組：安全

private transient Entry<?,?>[] table;

3、構造函數

HashTable有四個構造函數，能夠按照須要進行選擇。通常狀況下，若是知道節點數量，能夠在初始化的時候指定哈希桶的容量。數據結構

// 無參構造器
public Hashtable() {
        this(11, 0.75f); // 默認哈希桶初始容量爲11，負載因子爲0.75
}

// 自定義初始哈希桶容量構造器
public Hashtable(int initialCapacity) {
        this(initialCapacity, 0.75f);
}

// 自定義容量和負載因子構造器，負載因子通常狀況下使用0.75
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];
        // 初始化擴容閾值，節點超過這個值會進行擴容，其中MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
        threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
}

// 能夠在構造器中傳入Map，其所有元素會put到新構建的HashTable中
public Hashtable(Map<? extends K, ? extends V> t) {
        this(Math.max(2*t.size(), 11), 0.75f);
        putAll(t);
}

4、存儲實現

HashTable的put、get方法都使用了同步加鎖，因此他們是線程安全的。框架

1.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;
        // key直接獲取哈希值，所以key不能爲空，不然會拋空指針異常
        int hash = key.hashCode();
        // 計算在哈希桶的位置
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        Entry<K,V> entry = (Entry<K,V>)tab[index];
        // 判斷index位置是否爲空，不爲空判斷hash和key是否相等，相等的話覆蓋原有的value
        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;
}

// 添加新節點到哈希桶
private void addEntry(int hash, K key, V value, int index) {
        // 修改數加一，fast-fail機制
        modCount++;

        Entry<?,?> tab[] = table;
        // 判斷是否須要擴容，節點總數等於等於閾值就會擴容，閾值通常等於容量乘以0.75
        if (count >= threshold) {
            // Rehash the table if the threshold is exceeded
            rehash();

            tab = table;
            hash = key.hashCode();
            // 計算index位置
            index = (hash & 0x7FFFFFFF) % tab.length;
        }

        // 建立新的節點，並放到哈希桶中，若是有鏈表則是鏈表的頭部
        @SuppressWarnings("unchecked")
        Entry<K,V> e = (Entry<K,V>) tab[index];
        tab[index] = new Entry<>(hash, key, value, e);
        // 節點總數加一
        count++;
}

2.get方法性能

// 同步加鎖
public synchronized V get(Object key) {
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        // 根據hash值計算在哈希桶的位置
        int index = (hash & 0x7FFFFFFF) % tab.length;
        // 若是哈希桶的位置上是鏈表，則遍歷鏈表找到hash值和key都相等的對象
        for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                return (V)e.value;
            }
        }
        return null;
}

5、擴容機制

HashTable的擴容是把原來的容量擴大爲2倍加一，並把舊哈希桶的節點從新計算哈希映射到新的哈希桶this

protected void rehash() {
        int oldCapacity = table.length;
        Entry<?,?>[] oldMap = table;

        // 新容量等於舊容量的兩倍加1，不太清楚爲何要加一，我估計是爲了平均節點到哈希桶，減小哈希碰撞
        int newCapacity = (oldCapacity << 1) + 1;
        if (newCapacity - MAX_ARRAY_SIZE > 0) {
            // 若是就容量已經達到最大值就不在擴容了，MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
            if (oldCapacity == MAX_ARRAY_SIZE)
                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;
            }
        }
}

6、遍歷實現

HashTable的遍歷操做也是線程安全的，經過調用Collections.synchronizedSet()的方法，給遍歷操做加了一個包裝器。裏面對key、value或者key-value的遍歷實現仍是挺有借鑑意思的，它用泛型只要寫一次代碼就能夠實現三種遍歷方式。

// 該方法返回一個Set，其實遍歷只須要迭代器，entrySet返回的Set對象實現了迭代器
public Set<Map.Entry<K,V>> entrySet() {
        if (entrySet==null)
            // 返回線程安全的集合類，這裏是經過線程安全的方法對目標方法作了一層包裝
            entrySet = Collections.synchronizedSet(new EntrySet(), this);
        return entrySet;
}

簡單看看EntrySet的實現

// 只看迭代器部分
private class EntrySet extends AbstractSet<Map.Entry<K,V>> {
        public Iterator<Map.Entry<K,V>> iterator() {
            return getIterator(ENTRIES);
        }
}

private <T> Iterator<T> getIterator(int type) {
        // 判斷節點數是否爲0
        if (count == 0) {
            return Collections.emptyIterator();
        } else {
            return new Enumerator<>(type, true);
        }
}

// HashTable的內部類，能夠共用外部類的屬性和方法
private class Enumerator<T> implements Enumeration<T>, Iterator<T> {
        Entry<?,?>[] table = Hashtable.this.table;
        int index = table.length;
        Entry<?,?> entry = null;
        Entry<?,?> lastReturned = null;
        int type;

        boolean iterator;

        protected int expectedModCount = modCount;

        Enumerator(int type, boolean iterator) {
            this.type = type;
            this.iterator = iterator;
        }

        public boolean hasMoreElements() {
            Entry<?,?> e = entry;
            int i = index;
            Entry<?,?>[] t = table;
            // 從哈希桶的最後遍歷節點
            while (e == null && i > 0) {
                e = t[--i];
            }
            entry = e;
            index = i;
            return e != null;
        }

        @SuppressWarnings("unchecked")
        public T nextElement() {
            Entry<?,?> et = entry;
            int i = index;
            Entry<?,?>[] t = table;
            // 若是當前節點爲空，表示index位置的節點遍歷完了，則繼續遍歷哈希桶
            while (et == null && i > 0) {
                et = t[--i];
            }
            entry = et;
            index = i;
            if (et != null) {
                Entry<?,?> e = lastReturned = entry;
                entry = e.next;
                // 這裏使用了泛型能夠返回key，value或者key-value對象
                return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e);
            }
            throw new NoSuchElementException("Hashtable Enumerator");
        }

        // 迭代器方法
        public boolean hasNext() {
            return hasMoreElements();
        }
 
        // 迭代器方法
        public T next() {
            // fast-fail機制
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            return nextElement();
        }
        // 迭代器方法，刪除節點
        public void remove() {
            if (!iterator)
                throw new UnsupportedOperationException();
            if (lastReturned == null)
                throw new IllegalStateException("Hashtable Enumerator");
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();

            synchronized(Hashtable.this) {
                Entry<?,?>[] tab = Hashtable.this.table;
                int index = (lastReturned.hash & 0x7FFFFFFF) % tab.length;
                // 找出當前要刪除的節點在哈希桶的位置
                @SuppressWarnings("unchecked")
                Entry<K,V> e = (Entry<K,V>)tab[index];
                // 遍歷index位置的鏈表
                for(Entry<K,V> prev = null; e != null; prev = e, e = e.next) {
                    // 找出當前遍歷的節點
                    if (e == lastReturned) {
                        modCount++;
                        expectedModCount++;
                        // 判斷是否在鏈表的頭部
                        if (prev == null)
                            tab[index] = e.next;
                        else
                            prev.next = e.next;
                        count--;
                        lastReturned = null;
                        return;
                    }
                }
                throw new ConcurrentModificationException();
            }
        }
    }

7、總結

HashTable的數據結構跟HashMap相似，下面總結一下他們的區別：

key-value是否能夠爲空。HashTable的key和value都不能夠爲空，爲空會報空指針異常。HashMap的key，value均可覺得空，可是key只能有一個爲null，value均可覺得空。
是否線程安全。HashTable操做節點的方法都是同步加鎖的，因此是線程安全的。HashMap不是線程安全的。
類繼承關係是否同樣。HashTable繼承Dictionary。HashMap繼承AbstractMap。
初始容量。HashTable初始容量爲11。HashMap初始容量爲16。
最大容量（哈希桶的容量，不是存儲元素的容量）。HashTable最大爲Integer.MAX_VALUE - 8=2147483639。HashMap最大爲1<<30=1073741824。

以上就是我對HashTable的解讀，若是有錯誤之處，歡迎批評和指正。