2. 程式人生 > 程式設計 >詳解Java中的HashTable

詳解Java中的HashTable

阿新 • • 發佈：2020-12-04

概論

HashTable是遺留類，很多對映的常用功能與HashMap類似，不同的是它承自Dictionary類，並且是執行緒安全的，併發性不如ConcurrentHashMap，因為ConcurrentHashMap引入了分段鎖。

Hashtable不建議在新程式碼中使用，不需要執行緒安全的場合可以用HashMap替換，需要執行緒安全的場合可以用ConcurrentHashMap替換。

對比HashMap 的初始容量

預設11 的初始容量
需要注意的是Hashtable的預設初始容量大小是11，而HashMap 是16,但是他們的載入因子都是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 an empty <tt>HashMap</tt> with the default initial capacity
 * (16) and the default load factor (0.75).
 */
public HashMap() {
  this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

任意指定非負的容量
還有一點就是Hashtable的initialCapacity 也就是初始容量是是可以是你指定的任何非負整數，也就是你給它設定個0 也可以的

public Hashtable(int initialCapacity) {
  this(initialCapacity,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 的初始容量就不那麼聽話了，預設情況下，當我們設定HashMap的初始化容量時，實際上HashMap會採用第一個大於該數值的2的冪作為初始化容量(0 1 除外)

public HashMap(int initialCapacity,float loadFactor) {
  if (initialCapacity < 0)
    throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
  if (initialCapacity > MAXIMUM_CAPACITY)
    initialCapacity = MAXIMUM_CAPACITY;
  if (loadFactor <= 0 || Float.isNaN(loadFactor))
    throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
  this.loadFactor = loadFactor;
  this.threshold = tableSizeFor(initialCapacity);
}

對比HashMap 的 對null 值的支援

HashTable key value 都不支援null
首先HashMap 是支援null 值做key和value 的，但是HashTable 是不支援的，key 也不支援 value 也不支援

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;
}

聰明的你們發現了嗎，上面值檢測了value ==null 則丟擲NPE 但是沒有說key 啊，因為如果key 是null 的話，key.hashCode()則會丟擲異常，根本不需要判斷，但是value 就不會丟擲來

但是需要注意的實HashMap 對null 值雖然支援，但是可以從hash值的計算方法中看出，<null,value>的鍵值對，value 會覆蓋的。

static final int hash(Object key) {
  int h;
  return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

升級HashTable 使其支援null 做value
大部分程式碼都是直接copy 的HashTable，只去掉了value 的空值檢測

public class BuerHashTable<K,V> extends Hashtable<K,V> {
		// ..... 省略了部分程式碼，直接copy HashTable 的即可，主要是BuerHashTable.Entry 的定義和構造方法
  public synchronized V put(K key,V value) {

    // 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>)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,index);
    return null;
  }
  private void addEntry(int hash,K key,V value,int index) {
    modCount++;

    BuerHashTable.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")
    BuerHashTable.Entry<K,V> e = (BuerHashTable.Entry<K,V>) tab[index];
    tab[index] = new BuerHashTable.Entry<>(hash,e);
    count++;
  }
}

接下來，就可以將null 值作為value 存入BuerHashTable 了

BuerHashTable<String,String> buerHashTable = new BuerHashTable<>();
buerHashTable.put("a",null);

對比 HashTable 的繼承關係

詳解Java中的HashTable

Dictionary

這個類是HashTable特有繼承的，HashMap 是沒有繼承的，但是這個抽象類其實是沒有多大意義的,因為它的方法都在Map介面中有，其實這個就是個歷史問題了，因為Map介面是在Java1.2 中才加進去的，而Dictionary抽象類在Java1.0中就存在了

public abstract
class Dictionary<K,V> {
  public Dictionary() {
  }
  abstract public int size();
  abstract public boolean isEmpty();
  abstract public Enumeration<K> keys();
  abstract public Enumeration<V> elements();
  abstract public V get(Object key);
  /**
   * @exception NullPointerException if the <code>key</code> or
   */
  abstract public V put(K key,V value);
  abstract public V remove(Object key);
}

這個地方的NullPointerException 對應的就是HashTable 中put 方法中的null 值檢測

最後一點就是Dictionary 抽象類上的註釋，新的實現應該實現Map 介面而不是該抽象類

NOTE: This class is obsolete. New implementations should implement the Map interface,rather than extending this class

其實HashMap更準確地說是繼承自AbstractMap類，而不是直接實現了Map 介面，所以要是Dictionary這個抽象類要是實現的實Map 介面，那HashMap和Hashtable 就在繼承關係上保持一致了

Hashtable

執行緒安全

其實HashTable 沒有那麼多要說的，比較重要的一點就是執行緒安全，但是這個執行緒安全的實現方式就是所有的操作都加了synchronized關鍵字，哈哈！ 關於synchronized 我們後面會說

public synchronized int size() {}
public synchronized boolean isEmpty() {}
public synchronized boolean contains(Object value) {}
public synchronized boolean containsKey(Object key) {}
public synchronized V get(Object key) {}
public synchronized V put(K key,V value) {}
public synchronized V remove(Object key) {}

而HashMap 是執行緒不安全的

contains方法
HashMap中沒有Hashtable中的contains方法，只有containsValue和containsKey，因為contains方法容易讓人引起誤解。

Hashtable則保留了contains，containsValue和containsKey三個方法，其中contains和containsValue功能相同。

debug 原始碼 put 方法

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 不存在，存在咋地，覆蓋又咋地
  Entry<?,?> tab[] = table;
  // 雜湊值的計算不同，HashTable直接使用物件的hashCode。而HashMap重新計算hash值(高16位異或低16位)
  int hash = key.hashCode();
  // 計算下標 HashMap 是計算key的hash再與tab.length-1進行與運算；
  // HashTable則是key的hash值與0x7FFFFFFF進行與運算，然後再對tab.length取模
  // 先hash&0x7FFFFFFF後，再對length取模，與0x7FFFFFFF的目的是為了將負的hash值轉化為正值，因為hash值有可能為負數，而&0x7FFFFFFF後，只有符號外改變，而後面的位都不變
  int index = (hash & 0x7FFFFFFF) % tab.length;
  @SuppressWarnings("unchecked")
  // 確定 index 位置上的連結串列頭，這裡主要是遍歷連結串列找到key 值相等的節點，然後返回old value，這樣的話就不用新增新值
  // 也就是不用呼叫addEntry 方法
  Entry<K,V>)tab[index];
  // 存在key 
  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,index);
  // 返回null 
  return null;
}
private void addEntry(int hash,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];
  // e 也就是 tab[index] 是這個連結串列的頭結點， tab[index] = new Entry<>(hash,e); 也就是將元素新增到連結串列的頭部，e 做為new Entry<>(hash,e)的next 節點
  tab[index] = new Entry<>(hash,e);
  count++;
}

這裡我們對比一下HashMap 的新增方法,很明顯別人都是新增的連結串列尾部的，因為HashTable 是執行緒安全的，在這個前提下，使用頭查法效能更好，否則還有遍歷到連結串列的尾部插入

for (int binCount = 0; ; ++binCount) {
  if ((e = p.next) == null) {
    p.next = newNode(hash,null);
    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
      treeifyBin(tab,hash);
    break;
  }
  if (e.hash == hash &&
    ((k = e.key) == key || (key != null && key.equals(k))))
    break;
  p = e;
}

最後我們再看一下擴容的方法

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

  // overflow-conscious code 
  // 擴容成2倍+1
  int newCapacity = (oldCapacity << 1) + 1;
  // 這裡判斷是否超出了容量限制
  if (newCapacity - MAX_ARRAY_SIZE > 0) {
    if (oldCapacity == MAX_ARRAY_SIZE)
      // Keep running with MAX_ARRAY_SIZE buckets
      return;
    // 最大容量 MAX_ARRAY_SIZE  
    newCapacity = MAX_ARRAY_SIZE;
  }
  // 建立新的陣列
  Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];
  modCount++;
  // 更新 threshold
  threshold = (int)Math.min(newCapacity * loadFactor,MAX_ARRAY_SIZE + 1);
  table = newMap;
  // 資料遷移，遍歷陣列
  for (int i = oldCapacity ; i-- > 0 ;) {
  		// for 迴圈的方式遍歷連結串列
    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;
    }
  }
}

總結

  1. 需要注意的是Hashtable的預設初始容量大小是11，而HashMap 是16,但是他們的載入因子都是0.75f
  2. HashTable的初始容量可以使任何非負整數，但是HashMap會採用第一個大於該數值的2的冪作為初始化容量(0 1 除外，都是 1)
  3. HashTable的執行緒安全是完全藉助synchronized 的加持
  4. HashTable 的元素是頭插法，也就是插入到連結串列的頭部，因為HashTable 是執行緒安全的，在這個前提下，使用頭查法效能更好，否則還有遍歷到連結串列的尾部插入
  5. HashTable 是沒有紅黑樹支援的，就是不論連結串列的長度有多長，都不會轉化成紅黑樹
  6. 雜湊值的計算不同，HashTable直接使用物件的hashCode。而HashMap重新計算hash值(高16位異或低16位)，並且HashMap 支援key 為null 就是在這裡的
  7. Hashtable擴容時，將容量變為原來的2倍加1，而HashMap擴容時，將容量變為原來的2倍。

你覺得HashTable 還有什麼可以改進的地方嗎，歡迎討論
和上一節一樣這裡我依然給出這個思考題，雖然我們的說法可能不對，可能我們永遠也站不到原始碼作者當年的高度，但是我們依然積極思考，大膽討論

雖然java 原始碼的山很高，如果你想跨越，至少你得有登山的勇氣，這裡我給出自己的一點點愚見，希望各位不吝指教

int hash = key.hashCode();
addEntry(hash,index);
private void addEntry(int hash,int index) {
		// 記錄修改，快速失敗
  modCount++;
  Entry<?,?> tab[] = table;
  // count 實際儲存的key-value 數目，在HashMap 中用size 表示
  if (count >= threshold) {
    // Rehash the table if the threshold is exceeded
    rehash();
    tab = table;
    // 咋地，陣列擴容之後key 的hash值會變嗎，你還有重新計算一下
    hash = key.hashCode();
    index = (hash & 0x7FFFFFFF) % tab.length;
  }
  // Creates the new entry.
  @SuppressWarnings("unchecked")
  Entry<K,V>) tab[index];
  tab[index] = new Entry<>(hash,e);
  count++;
}

當然這只是小問題，但是也有很多其他小問題，例如求index 時候的計算方式是直接取模，而不是用與運算，它最大的問題在設計上，例如hash值的計算方式就沒有HashMap 設計的好，還有就是沒有紅黑樹的支援，還有就是執行緒安全的實現方式也不高效，所以我們說它好像是遺留類,HashTable 在Java1.0 時代就存在了，而HashMap才是Java1.2才有的。

以上就是詳解Java中的HashTable的詳細內容，更多關於Java HashTable的資料請關注我們其它相關文章！

相關推薦

詳解Java中的HashTable

概論 HashTable是遺留類，很多對映的常用功能與HashMap類似，不同的是它承自Dictionary類，並且是執行緒安全的，併發性不如ConcurrentHashMap，因為ConcurrentHashMap引入了分段鎖。

詳解Java中Math.round()的取整規則

做Java的面試題時遇到了以下這題，百度了一下Math.round()的修約規則，有的說是四捨五入，有的說是四捨六入，發現和我學分析化學時用的數字修約規則（四捨六入五成雙）很像，所以驗證一下；

詳解JAVA中static的作用

1、深度總結 　　引用一位網友的話，說的非常好，如果別人問你static的作用；如果你說靜態修飾 類的屬性 和 類的方法 別人認為你是合格的；如果是說 可以構成 靜態程式碼塊，那別人認為你還可以； 如果你說可以構成

詳解java中的阻塞佇列

阻塞佇列簡介 阻塞佇列(BlockingQueue)首先是一個支援先進先出的佇列，與普通的佇列完全相同；

詳解java中的static關鍵字

Java中的static關鍵字可以用於修飾變數、方法、程式碼塊和類，還可以與import關鍵字聯合使用，使用的方式不同賦予了static關鍵字不同的作用，且在開發中使用廣泛，這裡做一下深入瞭解。

詳解Java中NullPointerException異常的原因詳解以及解決方法

NullPointerException是當您嘗試使用指向記憶體中空位置的引用（null）時發生的異常，就好像它引用了一個物件一樣。

詳解Java中的字串

字串常量池詳解 在深入學習字串類之前, 我們先搞懂JVM是怎樣處理新生字串的.

詳解Java中native方法的使用

今天在網上學習時碰到有關於 native修飾符所修飾的方法，上網查了查，覺得很有意思記錄一下

詳解Java中的BigDecimal

今天碰到一個問題，金額計算用double型別會丟失經度，就改用了BigDecimal型別，這個型別之前用的比較少，沒怎麼接觸。就到網上看了一下相關教程，寫個總結記一下。

詳解Java中的日期類

Java 程式語言中時間的處理類有 Date類與 Calendar類。目前官方不推薦使用 Date類,因為其不利於國際化；而是推薦使用 Calendar類，並使用 DateFormat 類做格式化處理。

詳解java中DelayQueue的使用

簡介 今天給大家介紹一下DelayQueue,DelayQueue是BlockingQueue的一種，所以它是執行緒安全的，DelayQueue的特點就是插入Queue中的資料可以按照自定義的delay時間進行排序。只有delay時間小於0的元素才能夠被取出。

詳解Java中方法next()和nextLine()的區別與易錯點

1、基本語法 1.1基本使用方法 本篇部落格重點nextLine()會讀取換行(\'\\r\')，但是不會進行輸出。

詳解Java 中的 AutoCloseable 介面

一、前言 最近用到了 JDK 7 中的新特性 try-with-resources 語法，感覺到程式碼相對簡潔了很多，於是花了點時間詳細學習了下，下面分享給大家我的學習成果。

詳解java中if語句和switch的使用

if語句 說起if語句，那麼不得不提起三元運算子 a>b?c=0:c=1; 如果a>b結果為true，那麼c=0,為false,c=1

詳解Java中String JSONObject JSONArray List&lt;實體類&gt;轉換

JSON使用阿里的fastJson為依賴包 gradle依賴管理如下： compile group: \'com.alibaba\',name: \'fastjson\',version:\'1.2.41\'

詳解Java中的pinpoint1.8.5安裝及使用指南

pinpoint1.8.5安裝及使用指南 簡介 pinpoint是開源在github上的一款APM監控工具，它是用Java編寫的，用於大規模分散式系統監控。它對效能的影響最小（只增加約3％資源利用率），安裝agent是無侵入式的。

詳解Java中的延時佇列 DelayQueue

當用戶超時未支付時，給使用者發提醒訊息。另一種場景是，超時未付款，訂單自動取消。通常，訂單建立的時候可以向延遲佇列種插入一條訊息，到時間自動執行。其實，也可以用臨時表，把這些未支付的訂單放到一個臨時表

詳解java中static關鍵詞的作用

在java中，static是一個修飾符，用於修飾類的成員方法、類的成員變數，另外可以編寫static程式碼塊來優化程式效能；被static關鍵字修飾的方法或者變數不需要依賴於物件來進行訪問，只要類被載入了，就可以通過類名去

詳解Java中的ReentrantLock鎖

ReentrantLock鎖 ReentrantLock是Java中常用的鎖，屬於樂觀鎖型別，多執行緒併發情況下。能保證共享資料安全性，執行緒間有序性

詳解JAVA中priorityqueue的具體使用

Java中PriorityQueue通過二叉小頂堆實現，可以用一棵完全二叉樹表示。本文從Queue介面函數出發，結合生動的圖解，深入淺出地分析PriorityQueue每個操作的具體過程和時間複雜度，將讓讀者建立對PriorityQueue建立清晰