碼上歡樂
相關內容    簡體    繁體

HashTable和HashMap的區別詳解

本文轉載自   查看原文   2018-05-28 11:18   157184    Java
 

一、HashMap簡介

      HashMap是基於哈希表實現的，每一個元素是一個key-value對，其內部通過單鏈表解決沖突問題，容量不足（超過了閥值）時，同樣會自動增長。

      HashMap是非線程安全的，只是用於單線程環境下，多線程環境下可以采用concurrent並發包下的concurrentHashMap。

      HashMap 實現了Serializable接口，因此它支持序列化，實現了Cloneable接口，能被克隆。

      HashMap存數據的過程是：

      HashMap內部維護了一個存儲數據的Entry數組，HashMap采用鏈表解決沖突，每一個Entry本質上是一個單向鏈表。當准備添加一個key-value對時，首先通過hash(key)方法計算hash值，然后通過indexFor(hash,length)求該key-value對的存儲位置，計算方法是先用hash&0x7FFFFFFF后，再對length取模，這就保證每一個key-value對都能存入HashMap中，當計算出的位置相同時，由於存入位置是一個鏈表，則把這個key-value對插入鏈表頭。

      HashMap中key和value都允許為null。key為null的鍵值對永遠都放在以table[0]為頭結點的鏈表中。

      了解了數據的存儲，那么數據的讀取也就很容易就明白了。

      HashMap的存儲結構，如下圖所示：

 

      圖中，紫色部分即代表哈希表，也稱為哈希數組，數組的每個元素都是一個單鏈表的頭節點，鏈表是用來解決沖突的，如果不同的key映射到了數組的同一位置處，就將其放入單鏈表中。

      HashMap內存儲數據的Entry數組默認是16，如果沒有對Entry擴容機制的話，當存儲的數據一多，Entry內部的鏈表會很長，這就失去了HashMap的存儲意義了。所以HasnMap內部有自己的擴容機制。HashMap內部有：

      變量size，它記錄HashMap的底層數組中已用槽的數量；

      變量threshold，它是HashMap的閾值，用於判斷是否需要調整HashMap的容量（threshold = 容量*加載因子）    

      變量DEFAULT_LOAD_FACTOR = 0.75f，默認加載因子為0.75

      HashMap擴容的條件是：當size大於threshold時，對HashMap進行擴容  

      擴容是是新建了一個HashMap的底層數組，而后調用transfer方法，將就HashMap的全部元素添加到新的HashMap中（要重新計算元素在新的數組中的索引位置）。 很明顯，擴容是一個相當耗時的操作，因為它需要重新計算這些元素在新的數組中的位置並進行復制處理。因此，我們在用HashMap的時，最好能提前預估下HashMap中元素的個數，這樣有助於提高HashMap的性能。

      HashMap共有四個構造方法。構造方法中提到了兩個很重要的參數：初始容量和加載因子。這兩個參數是影響HashMap性能的重要參數，其中容量表示哈希表中槽的數量（即哈希數組的長度），初始容量是創建哈希表時的容量（從構造函數中可以看出，如果不指明，則默認為16），加載因子是哈希表在其容量自動增加之前可以達到多滿的一種尺度，當哈希表中的條目數超出了加載因子與當前容量的乘積時，則要對該哈希表進行 resize 操作（即擴容）。

      下面說下加載因子，如果加載因子越大，對空間的利用更充分，但是查找效率會降低（鏈表長度會越來越長）；如果加載因子太小，那么表中的數據將過於稀疏（很多空間還沒用，就開始擴容了），對空間造成嚴重浪費。如果我們在構造方法中不指定，則系統默認加載因子為0.75，這是一個比較理想的值，一般情況下我們是無需修改的。

       另外，無論我們指定的容量為多少，構造方法都會將實際容量設為不小於指定容量的2的次方的一個數，且最大值不能超過2的30次方

      對HashMap想進一步深入了解的朋友推薦看一下HashMap源碼剖析：http://blog.csdn.net/ns_code/article/details/36034955

 

二、Hashtable簡介

 

      Hashtable同樣是基於哈希表實現的，同樣每個元素是一個key-value對，其內部也是通過單鏈表解決沖突問題，容量不足（超過了閥值）時，同樣會自動增長。

      Hashtable也是JDK1.0引入的類，是線程安全的，能用於多線程環境中。

      Hashtable同樣實現了Serializable接口，它支持序列化，實現了Cloneable接口，能被克隆。

      Hashtable和HashMap比較相似，感興趣的朋友可以看“Hashtable源碼剖析”這篇博客：http://blog.csdn.net/ns_code/article/details/36191279

下面主要介紹一下HashTable和HashMap區別

 

三、HashTable和HashMap區別

      1、繼承的父類不同

 

      Hashtable繼承自Dictionary類，而HashMap繼承自AbstractMap類。但二者都實現了Map接口。

      2、線程安全性不同

      javadoc中關於hashmap的一段描述如下：此實現不是同步的。如果多個線程同時訪問一個哈希映射，而其中至少一個線程從結構上修改了該映射，則它必須保持外部同步。

 

      Hashtable 中的方法是Synchronize的，而HashMap中的方法在缺省情況下是非Synchronize的。在多線程並發的環境下，可以直接使用Hashtable，不需要自己為它的方法實現同步，但使用HashMap時就必須要自己增加同步處理。（結構上的修改是指添加或刪除一個或多個映射關系的任何操作；僅改變與實例已經包含的鍵關聯的值不是結構上的修改。）這一般通過對自然封裝該映射的對象進行同步操作來完成。如果不存在這樣的對象，則應該使用 Collections.synchronizedMap 方法來“包裝”該映射。最好在創建時完成這一操作，以防止對映射進行意外的非同步訪問，如下所示：

      Map m = Collections.synchronizedMap(new HashMap(...));

      Hashtable 線程安全很好理解，因為它每個方法中都加入了Synchronize。這里我們分析一下HashMap為什么是線程不安全的：

 

      HashMap底層是一個Entry數組，當發生hash沖突的時候，hashmap是采用鏈表的方式來解決的，在對應的數組位置存放鏈表的頭結點。對鏈表而言，新加入的節點會從頭結點加入。

我們來分析一下多線程訪問：

 

      （1）在hashmap做put操作的時候會調用下面方法：

 

[java]  view plain  copy
 
  1. // 新增Entry。將“key-value”插入指定位置，bucketIndex是位置索引。      
  2.     void addEntry(int hash, K key, V value, int bucketIndex) {      
  3.         // 保存“bucketIndex”位置的值到“e”中      
  4.         Entry<K,V> e = table[bucketIndex];      
  5.         // 設置“bucketIndex”位置的元素為“新Entry”，      
  6.         // 設置“e”為“新Entry的下一個節點”      
  7.         table[bucketIndex] = new Entry<K,V>(hash, key, value, e);      
  8.         // 若HashMap的實際大小 不小於 “閾值”，則調整HashMap的大小      
  9.         if (size++ >= threshold)      
  10.             resize(2 * table.length);      
  11.     }  

 

      在hashmap做put操作的時候會調用到以上的方法。現在假如A線程和B線程同時對同一個數組位置調用addEntry，兩個線程會同時得到現在的頭結點，然后A寫入新的頭結點之后，B也寫入新的頭結點，那B的寫入操作就會覆蓋A的寫入操作造成A的寫入操作丟失

（      2）刪除鍵值對的代碼

 

[java]  view plain  copy
 
  1. <span style="font-size: 18px;">      </span>// 刪除“鍵為key”的元素      
  2.     final Entry<K,V> removeEntryForKey(Object key) {      
  3.         // 獲取哈希值。若key為null，則哈希值為0；否則調用hash()進行計算      
  4.         int hash = (key == null) ? 0 : hash(key.hashCode());      
  5.         int i = indexFor(hash, table.length);      
  6.         Entry<K,V> prev = table[i];      
  7.         Entry<K,V> e = prev;      
  8.      
  9.         // 刪除鏈表中“鍵為key”的元素      
  10.         // 本質是“刪除單向鏈表中的節點”      
  11.         while (e != null) {      
  12.             Entry<K,V> next = e.next;      
  13.             Object k;      
  14.             if (e.hash == hash &&      
  15.                 ((k = e.key) == key || (key != null && key.equals(k)))) {      
  16.                 modCount++;      
  17.                 size--;      
  18.                 if (prev == e)      
  19.                     table[i] = next;      
  20.                 else     
  21.                     prev.next = next;      
  22.                 e.recordRemoval(this);      
  23.                 return e;      
  24.             }      
  25.             prev = e;      
  26.             e = next;      
  27.         }      
  28.      
  29.         return e;      
  30.     }  

 

      當多個線程同時操作同一個數組位置的時候，也都會先取得現在狀態下該位置存儲的頭結點，然后各自去進行計算操作，之后再把結果寫會到該數組位置去，其實寫回的時候可能其他的線程已經就把這個位置給修改過了，就會覆蓋其他線程的修改

      （3）addEntry中當加入新的鍵值對后鍵值對總數量超過門限值的時候會調用一個resize操作，代碼如下：

[java]  view plain  copy
 
  1. // 重新調整HashMap的大小，newCapacity是調整后的容量      
  2.     void resize(int newCapacity) {      
  3.         Entry[] oldTable = table;      
  4.         int oldCapacity = oldTable.length;     
  5.         //如果就容量已經達到了最大值，則不能再擴容，直接返回    
  6.         if (oldCapacity == MAXIMUM_CAPACITY) {      
  7.             threshold = Integer.MAX_VALUE;      
  8.             return;      
  9.         }      
  10.      
  11.         // 新建一個HashMap，將“舊HashMap”的全部元素添加到“新HashMap”中，      
  12.         // 然后，將“新HashMap”賦值給“舊HashMap”。      
  13.         Entry[] newTable = new Entry[newCapacity];      
  14.         transfer(newTable);      
  15.         table = newTable;      
  16.         threshold = (int)(newCapacity * loadFactor);      
  17.     }  

      這個操作會新生成一個新的容量的數組，然后對原數組的所有鍵值對重新進行計算和寫入新的數組，之后指向新生成的數組。

 

      當多個線程同時檢測到總數量超過門限值的時候就會同時調用resize操作，各自生成新的數組並rehash后賦給該map底層的數組table，結果最終只有最后一個線程生成的新數組被賦給table變量，其他線程的均會丟失。而且當某些線程已經完成賦值而其他線程剛開始的時候，就會用已經被賦值的table作為原始數組，這樣也會有問題。

      3、是否提供contains方法

 

      HashMap把Hashtable的contains方法去掉了，改成containsValue和containsKey，因為contains方法容易讓人引起誤解。

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

我們看一下Hashtable的ContainsKey方法和ContainsValue的源碼：

[java]  view plain  copy
 
  1. public boolean containsValue(Object value) {      
  2.      return contains(value);      
  3.  }  

[java]  view plain  copy
 
  1. // 判斷Hashtable是否包含“值(value)”      
  2.  public synchronized boolean contains(Object value) {      
  3.      //注意，Hashtable中的value不能是null，      
  4.      // 若是null的話，拋出異常!      
  5.      if (value == null) {      
  6.          throw new NullPointerException();      
  7.      }      
  8.     
  9.      // 從后向前遍歷table數組中的元素(Entry)      
  10.      // 對於每個Entry(單向鏈表)，逐個遍歷，判斷節點的值是否等於value      
  11.      Entry tab[] = table;      
  12.      for (int i = tab.length ; i-- > 0 ;) {      
  13.          for (Entry<K,V> e = tab[i] ; e != null ; e = e.next) {      
  14.              if (e.value.equals(value)) {      
  15.                  return true;      
  16.              }      
  17.          }      
  18.      }      
  19.      return false;      
  20.  }  

 

[java]  view plain  copy
 
  1. // 判斷Hashtable是否包含key      
  2.  public synchronized boolean containsKey(Object key) {      
  3.      Entry tab[] = table;      
  4. /計算hash值，直接用key的hashCode代替    
  5.      int hash = key.hashCode();        
  6.      // 計算在數組中的索引值     
  7.      int index = (hash & 0x7FFFFFFF) % tab.length;      
  8.      // 找到“key對應的Entry(鏈表)”，然后在鏈表中找出“哈希值”和“鍵值”與key都相等的元素      
  9.      for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {      
  10.          if ((e.hash == hash) && e.key.equals(key)) {      
  11.              return true;      
  12.          }      
  13.      }      
  14.      return false;      
  15.  }  

      下面我們看一下HashMap的ContainsKey方法和ContainsValue的源碼：

[java]  view plain  copy
 
  1. // HashMap是否包含key      
  2.     public boolean containsKey(Object key) {      
  3.         return getEntry(key) != null;      
  4.     }  

[java]  view plain  copy
 
  1. // 返回“鍵為key”的鍵值對      
  2.     final Entry<K,V> getEntry(Object key) {      
  3.         // 獲取哈希值      
  4.         // HashMap將“key為null”的元素存儲在table[0]位置，“key不為null”的則調用hash()計算哈希值      
  5.         int hash = (key == null) ? 0 : hash(key.hashCode());      
  6.         // 在“該hash值對應的鏈表”上查找“鍵值等於key”的元素      
  7.         for (Entry<K,V> e = table[indexFor(hash, table.length)];      
  8.              e != null;      
  9.              e = e.next) {      
  10.             Object k;      
  11.             if (e.hash == hash &&      
  12.                 ((k = e.key) == key || (key != null && key.equals(k))))      
  13.                 return e;      
  14.         }      
  15.         return null;      
  16.     }  

[java]  view plain  copy
 
  1. // 是否包含“值為value”的元素      
  2.     public boolean containsValue(Object value) {      
  3.     // 若“value為null”，則調用containsNullValue()查找      
  4.     if (value == null)      
  5.             return containsNullValue();      
  6.      
  7.     // 若“value不為null”，則查找HashMap中是否有值為value的節點。      
  8.     Entry[] tab = table;      
  9.         for (int i = 0; i < tab.length ; i++)      
  10.             for (Entry e = tab[i] ; e != null ; e = e.next)      
  11.                 if (value.equals(e.value))      
  12.                     return true;      
  13.     return false;      
  14.     }  

通過上面源碼的比較，我們可以得到第四個不同的地方

 

      4、key和value是否允許null值

 

      其中key和value都是對象，並且不能包含重復key，但可以包含重復的value。

      通過上面的ContainsKey方法和ContainsValue的源碼我們可以很明顯的看出：

      Hashtable中，key和value都不允許出現null值。但是如果在Hashtable中有類似put(null,null)的操作，編譯同樣可以通過，因為key和value都是Object類型，但運行時會拋出NullPointerException異常，這是JDK的規范規定的。
HashMap中，null可以作為鍵，這樣的鍵只有一個；可以有一個或多個鍵所對應的值為null。當get()方法返回null值時，可能是 HashMap中沒有該鍵，也可能使該鍵所對應的值為null。因此，在HashMap中不能由get()方法來判斷HashMap中是否存在某個鍵， 而應該用containsKey()方法來判斷。

      5、兩個遍歷方式的內部實現上不同

      Hashtable、HashMap都使用了 Iterator。而由於歷史原因，Hashtable還使用了Enumeration的方式 。

      6、hash值不同

      哈希值的使用不同，HashTable直接使用對象的hashCode。而HashMap重新計算hash值。

      hashCode是jdk根據對象的地址或者字符串或者數字算出來的int類型的數值。

      Hashtable計算hash值，直接用key的hashCode()，而HashMap重新計算了key的hash值，Hashtable在求hash值對應的位置索引時，用取模運算，而HashMap在求位置索引時，則用與運算，且這里一般先用hash&0x7FFFFFFF后，再對length取模，&0x7FFFFFFF的目的是為了將負的hash值轉化為正值，因為hash值有可能為負數，而&0x7FFFFFFF后，只有符號外改變，而后面的位都不變。

      7、內部實現使用的數組初始化和擴容方式不同

      HashTable在不指定容量的情況下的默認容量為11，而HashMap為16，Hashtable不要求底層數組的容量一定要為2的整數次冪，而HashMap則要求一定為2的整數次冪。
      Hashtable擴容時，將容量變為原來的2倍加1，而HashMap擴容時，將容量變為原來的2倍。

      Hashtable和HashMap它們兩個內部實現方式的數組的初始大小和擴容的方式。HashTable中hash數組默認大小是11，增加的方式是 old*2+1。


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 HashMap 和 Hashtable 有什么區別？ HashMap和Hashtable的區別 HashMap 與HashTable的區別 HashTable 和 HashMap 的區別 HashMap和HashTable的區別以及底層 HashMap與HashTable的區別 HashMap和HashTable區別 HashMap和Hashtable的區別 HashMap和Hashtable的區別 HashMap和Hashtable的詳細區別
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM