這一章,我們對Hashtable進行學習。
我們先對Hashtable有個整體認識,然後再學習它的源碼,最後再通過實例來學會使用Hashtable。
第1部分 Hashtable介紹
Hashtable 簡介
和HashMap一樣,Hashtable 也是一個散列表,它存儲的內容是鍵值對(key-value)映射。
Hashtable 繼承於Dictionary,實現了Map、Cloneable、java.io.Serializable接口。
Hashtable 的函數都是同步的,這意味著它是線程安全的。它的key、value都可以為null。此外,Hashtable中的映射不是有序的。
Hashtable 的實例有兩個參數影響其性能:初始容量 和 加載因子。容量 是哈希表中桶 的數量,初始容量 就是哈希表創建時的容量。注意,哈希表的狀態為 open:在發生“哈希沖突”的情況下,單個桶會存儲多個條目,這些條目必須按順序搜索。加載因子 是對哈希表在其容量自動增加之前可以達到多滿的一個尺度。初始容量和加載因子這兩個參數只是對該實現的提示。關於何時以及是否調用 rehash 方法的具體細節則依賴於該實現。
通常,默認加載因子是 0.75, 這是在時間和空間成本上尋求一種折衷。加載因子過高雖然減少了空間開銷,但同時也增加了查找某個條目的時間(在大多數 Hashtable 操作中,包括 get 和 put 操作,都反映了這一點)。
Hashtable的繼承關系
java.lang.Object
java.util.Dictionary<K, V>
java.util.Hashtable<K, V>
public class Hashtable<K,V> extends Dictionary<K,V>
implements Map<K,V>, Cloneable, java.io.Serializable { }
Hashtable與Map關系如下圖:
Hashtable的構造函數
// 默認構造函數。 public Hashtable() // 指定“容量大小”的構造函數 public Hashtable(int initialCapacity) // 指定“容量大小”和“加載因子”的構造函數 public Hashtable(int initialCapacity, float loadFactor) // 包含“子Map”的構造函數 public Hashtable(Map<? extends K, ? extends V> t)
Hashtable的API
synchronized void clear() synchronized Object clone() boolean contains(Object value) synchronized boolean containsKey(Object key) synchronized boolean containsValue(Object value) synchronized Enumeration<V> elements() synchronized Set<Entry<K, V>> entrySet() synchronized boolean equals(Object object) synchronized V get(Object key) synchronized int hashCode() synchronized boolean isEmpty() synchronized Set<K> keySet() synchronized Enumeration<K> keys() synchronized V put(K key, V value) synchronized void putAll(Map<? extends K, ? extends V> map) synchronized V remove(Object key) synchronized int size() synchronized String toString() synchronized Collection<V> values()
查看本欄目
第2部分 Hashtable源碼解析
為了更了解Hashtable的原理,下面對Hashtable源碼代碼作出分析。
在閱讀源碼時,建議參考後面的說明來建立對Hashtable的整體認識,這樣更容易理解Hashtable。
package java.util; import java.io.*; public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable { // Hashtable保存key-value的數組。 // Hashtable是采用拉鏈法實現的,每一個Entry本質上是一個單向鏈表 private transient Entry[] table; // Hashtable中元素的實際數量 private transient int count; // 阈值,用於判斷是否需要調整Hashtable的容量(threshold = 容量*加載因子) private int threshold; // 加載因子 private float loadFactor; // Hashtable被改變的次數 private transient int modCount = 0; // 序列版本號 private static final long serialVersionUID = 1421746759512286392L; // 指定“容量大小”和“加載因子”的構造函數 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)(initialCapacity * loadFactor); } // 指定“容量大小”的構造函數 public Hashtable(int initialCapacity) { this(initialCapacity, 0.75f); } // 默認構造函數。 public Hashtable() { // 默認構造函數,指定的容量大小是11;加載因子是0.75 this(11, 0.75f); } // 包含“子Map”的構造函數 public Hashtable(Map<? extends K, ? extends V> t) { this(Math.max(2*t.size(), 11), 0.75f); // 將“子Map”的全部元素都添加到Hashtable中 putAll(t); } public synchronized int size() { return count; } public synchronized boolean isEmpty() { return count == 0; } // 返回“所有key”的枚舉對象 public synchronized Enumeration<K> keys() { return this.<K>getEnumeration(KEYS); } // 返回“所有value”的枚舉對象 public synchronized Enumeration<V> elements() { return this.<V>getEnumeration(VALUES); } // 判斷Hashtable是否包含“值(value)” public synchronized boolean contains(Object value) { // Hashtable中“鍵值對”的value不能是null, // 若是null的話,拋出異常! if (value == null) { throw new NullPointerException(); } // 從後向前遍歷table數組中的元素(Entry) // 對於每個Entry(單向鏈表),逐個遍歷,判斷節點的值是否等於value Entry tab[] = table; for (int i = tab.length ; i-- > 0 ;) { for (Entry<K,V> e = tab[i] ; e != null ; e = e.next) { if (e.value.equals(value)) { return true; } } } return false; } public boolean containsValue(Object value) { return contains(value); } // 判斷Hashtable是否包含key public synchronized boolean containsKey(Object key) { Entry tab[] = table; int hash = key.hashCode(); // 計算索引值, // % tab.length 的目的是防止數據越界 int index = (hash & 0x7FFFFFFF) % tab.length; // 找到“key對應的Entry(鏈表)”,然後在鏈表中找出“哈希值”和“鍵值”與key都相等的元素 for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) { if ((e.hash == hash) && e.key.equals(key)) { return true; } } return false; } // 返回key對應的value,沒有的話返回null public synchronized V get(Object key) { Entry tab[] = table; int hash = key.hashCode(); // 計算索引值, int index = (hash & 0x7FFFFFFF) % tab.length; // 找到“key對應的Entry(鏈表)”,然後在鏈表中找出“哈希值”和“鍵值”與key都相等的元素 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的長度,將長度變成原來的(2倍+1) // (01) 將“舊的Entry數組”賦值給一個臨時變量。 // (02) 創建一個“新的Entry數組”,並賦值給“舊的Entry數組” // (03) 將“Hashtable”中的全部元素依次添加到“新的Entry數組”中 protected void rehash() { int oldCapacity = table.length; Entry[] oldMap = table; int newCapacity = oldCapacity * 2 + 1; Entry[] newMap = new Entry[newCapacity]; modCount++; threshold = (int)(newCapacity * loadFactor); table = newMap; for (int i = oldCapacity ; i-- > 0 ;) { for (Entry<K,V> old = oldMap[i] ; old != null ; ) { Entry<K,V> e = old; old = old.next; int index = (e.hash & 0x7FFFFFFF) % newCapacity; e.next = newMap[index]; newMap[index] = e; } } } // 將“key-value”添加到Hashtable中 public synchronized V put(K key, V value) { // Hashtable中不能插入value為null的元素!!! if (value == null) { throw new NullPointerException(); } // 若“Hashtable中已存在鍵為key的鍵值對”, // 則用“新的value”替換“舊的value” Entry tab[] = table; int hash = key.hashCode(); 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; } } // 若“Hashtable中不存在鍵為key的鍵值對”, // (01) 將“修改統計數”+1 modCount++; // (02) 若“Hashtable實際容量” > “阈值”(阈值=總的容量 * 加載因子) // 則調整Hashtable的大小 if (count >= threshold) { // Rehash the table if the threshold is exceeded rehash(); tab = table; index = (hash & 0x7FFFFFFF) % tab.length; } // (03) 將“Hashtable中index”位置的Entry(鏈表)保存到e中 Entry<K,V> e = tab[index]; // (04) 創建“新的Entry節點”,並將“新的Entry”插入“Hashtable的index位置”,並設置e為“新的Entry”的下一個元素(即“新Entry”為鏈表表頭)。 tab[index] = new Entry<K,V>(hash, key, value, e); // (05) 將“Hashtable的實際容量”+1 count++; return null; } // 刪除Hashtable中鍵為key的元素 public synchronized V remove(Object key) { Entry tab[] = table; int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; // 找到“key對應的Entry(鏈表)” // 然後在鏈表中找出要刪除的節點,並刪除該節點。 for (Entry<K,V> e = tab[index], 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; } // 將“Map(t)”的中全部元素逐一添加到Hashtable中 public synchronized void putAll(Map<? extends K, ? extends V> t) { for (Map.Entry<? extends K, ? extends V> e : t.entrySet()) put(e.getKey(), e.getValue()); } // 清空Hashtable // 將Hashtable的table數組的值全部設為null public synchronized void clear() { Entry tab[] = table; modCount++; for (int index = tab.length; --index >= 0; ) tab[index] = null; count = 0; } // 克隆一個Hashtable,並以Object的形式返回。 public synchronized Object clone() { try { Hashtable<K,V> t = (Hashtable<K,V>) super.clone(); t.table = new Entry[table.length]; for (int i = table.length ; i-- > 0 ; ) { t.table[i] = (table[i] != null) ? (Entry<K,V>) table[i].clone() : null; } t.keySet = null; t.entrySet = null; t.values = null; t.modCount = 0; return t; } catch (CloneNotSupportedException e) { // this shouldn't happen, since we are Cloneable throw new InternalError(); } } public synchronized String toString() { int max = size() - 1; if (max == -1) return "{}"; StringBuilder sb = new StringBuilder(); Iterator<Map.Entry<K,V>> it = entrySet().iterator(); sb.append('{'); for (int i = 0; ; i++) { Map.Entry<K,V> e = it.next(); K key = e.getKey(); V value = e.getValue(); sb.append(key == this ? "(this Map)" : key.toString()); sb.append('='); sb.append(value == this ? "(this Map)" : value.toString()); if (i == max) return sb.append('}').toString(); sb.append(", "); } } // 獲取Hashtable的枚舉類對象 // 若Hashtable的實際大小為0,則返回“空枚舉類”對象; // 否則,返回正常的Enumerator的對象。(Enumerator實現了迭代器和枚舉兩個接口) private <T> Enumeration<T> getEnumeration(int type) { if (count == 0) { return (Enumeration<T>)emptyEnumerator; } else { return new Enumerator<T>(type, false); } } // 獲取Hashtable的迭代器 // 若Hashtable的實際大小為0,則返回“空迭代器”對象; // 否則,返回正常的Enumerator的對象。(Enumerator實現了迭代器和枚舉兩個接口) private <T> Iterator<T> getIterator(int type) { if (count == 0) { return (Iterator<T>) emptyIterator; } else { return new Enumerator<T>(type, true); } } // Hashtable的“key的集合”。它是一個Set,意味著沒有重復元素 private transient volatile Set<K> keySet = null; // Hashtable的“key-value的集合”。它是一個Set,意味著沒有重復元素 private transient volatile Set<Map.Entry<K,V>> entrySet = null; // Hashtable的“key-value的集合”。它是一個Collection,意味著可以有重復元素 private transient volatile Collection<V> values = null; // 返回一個被synchronizedSet封裝後的KeySet對象 // synchronizedSet封裝的目的是對KeySet的所有方法都添加synchronized,實現多線程同步 public Set<K> keySet() { if (keySet == null) keySet = Collections.synchronizedSet(new KeySet(), this); return keySet; } // Hashtable的Key的Set集合。 // KeySet繼承於AbstractSet,所以,KeySet中的元素沒有重復的。 private class KeySet extends AbstractSet<K> { public Iterator<K> iterator() { return getIterator(KEYS); } public int size() { return count; } public boolean contains(Object o) { return containsKey(o); } public boolean remove(Object o) { return Hashtable.this.remove(o) != null; } public void clear() { Hashtable.this.clear(); } } // 返回一個被synchronizedSet封裝後的EntrySet對象 // synchronizedSet封裝的目的是對EntrySet的所有方法都添加synchronized,實現多線程同步 public Set<Map.Entry<K,V>> entrySet() { if (entrySet==null) entrySet = Collections.synchronizedSet(new EntrySet(), this); return entrySet; } // Hashtable的Entry的Set集合。 // EntrySet繼承於AbstractSet,所以,EntrySet中的元素沒有重復的。 private class EntrySet extends AbstractSet<Map.Entry<K,V>> { public Iterator<Map.Entry<K,V>> iterator() { return getIterator(ENTRIES); } public boolean add(Map.Entry<K,V> o) { return super.add(o); } // 查找EntrySet中是否包含Object(0) // 首先,在table中找到o對應的Entry(Entry是一個單向鏈表) // 然後,查找Entry鏈表中是否存在Object public boolean contains(Object o) { if (!(o instanceof Map.Entry)) return false; Map.Entry entry = (Map.Entry)o; Object key = entry.getKey(); Entry[] tab = table; int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; for (Entry e = tab[index]; e != null; e = e.next) if (e.hash==hash && e.equals(entry)) return true; return false; } // 刪除元素Object(0) // 首先,在table中找到o對應的Entry(Entry是一個單向鏈表) // 然後,刪除鏈表中的元素Object public boolean remove(Object o) { if (!(o instanceof Map.Entry)) return false; Map.Entry<K,V> entry = (Map.Entry<K,V>) o; K key = entry.getKey(); Entry[] tab = table; int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; for (Entry<K,V> e = tab[index], prev = null; e != null; prev = e, e = e.next) { if (e.hash==hash && e.equals(entry)) { modCount++; if (prev != null) prev.next = e.next; else tab[index] = e.next; count--; e.value = null; return true; } } return false; } public int size() { return count; } public void clear() { Hashtable.this.clear(); } } // 返回一個被synchronizedCollection封裝後的ValueCollection對象 // synchronizedCollection封裝的目的是對ValueCollection的所有方法都添加synchronized,實現多線程同步 public Collection<V> values() { if (values==null) values = Collections.synchronizedCollection(new ValueCollection(), this); return values; } // Hashtable的value的Collection集合。 // ValueCollection繼承於AbstractCollection,所以,ValueCollection中的元素可以重復的。 private class ValueCollection extends AbstractCollection<V> { public Iterator<V> iterator() { return getIterator(VALUES); } public int size() { return count; } public boolean contains(Object o) { return containsValue(o); } public void clear() { Hashtable.this.clear(); } } // 重新equals()函數 // 若兩個Hashtable的所有key-value鍵值對都相等,則判斷它們兩個相等 public synchronized boolean equals(Object o) { if (o == this) return true; if (!(o instanceof Map)) return false; Map<K,V> t = (Map<K,V>) o; if (t.size() != size()) return false; try { // 通過迭代器依次取出當前Hashtable的key-value鍵值對 // 並判斷該鍵值對,存在於Hashtable(o)中。 // 若不存在,則立即返回false;否則,遍歷完“當前Hashtable”並返回true。 Iterator<Map.Entry<K,V>> i = entrySet().iterator(); while (i.hasNext()) { Map.Entry<K,V> e = i.next(); K key = e.getKey(); V value = e.getValue(); if (value == null) { if (!(t.get(key)==null && t.containsKey(key))) return false; } else { if (!value.equals(t.get(key))) return false; } } } catch (ClassCastException unused) { return false; } catch (NullPointerException unused) { return false; } return true; } // 計算Hashtable的哈希值 // 若 Hashtable的實際大小為0 或者 加載因子<0,則返回0。 // 否則,返回“Hashtable中的每個Entry的key和value的異或值 的總和”。 public synchronized int hashCode() { int h = 0; if (count == 0 || loadFactor < 0) return h; // Returns zero loadFactor = -loadFactor; // Mark hashCode computation in progress Entry[] tab = table; for (int i = 0; i < tab.length; i++) for (Entry e = tab[i]; e != null; e = e.next) h += e.key.hashCode() ^ e.value.hashCode(); loadFactor = -loadFactor; // Mark hashCode computation complete return h; } // java.io.Serializable的寫入函數 // 將Hashtable的“總的容量,實際容量,所有的Entry”都寫入到輸出流中 private synchronized void writeObject(java.io.ObjectOutputStream s) throws IOException { // Write out the length, threshold, loadfactor s.defaultWriteObject(); // Write out length, count of elements and then the key/value objects s.writeInt(table.length); s.writeInt(count); for (int index = table.length-1; index >= 0; index--) { Entry entry = table[index]; while (entry != null) { s.writeObject(entry.key); s.writeObject(entry.value); entry = entry.next; } } } // java.io.Serializable的讀取函數:根據寫入方式讀出 // 將Hashtable的“總的容量,實際容量,所有的Entry”依次讀出 private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException { // Read in the length, threshold, and loadfactor s.defaultReadObject(); // Read the original length of the array and number of elements int origlength = s.readInt(); int elements = s.readInt(); // Compute new size with a bit of room 5% to grow but // no larger than the original size. 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 * loadFactor) + (elements / 20) + 3; if (length > elements && (length & 1) == 0) length--; if (origlength > 0 && length > origlength) length = origlength; Entry[] table = new Entry[length]; count = 0; // Read the number of elements and then all the key/value objects for (; elements > 0; elements--) { K key = (K)s.readObject(); V value = (V)s.readObject(); // synch could be eliminated for performance reconstitutionPut(table, key, value); } this.table = table; } private void reconstitutionPut(Entry[] tab, K key, V value) throws StreamCorruptedException { if (value == null) { throw new java.io.StreamCorruptedException(); } // Makes sure the key is not already in the hashtable. // This should not happen in deserialized version. int hash = key.hashCode(); 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)) { throw new java.io.StreamCorruptedException(); } } // Creates the new entry. Entry<K,V> e = tab[index]; tab[index] = new Entry<K,V>(hash, key, value, e); count++; } // Hashtable的Entry節點,它本質上是一個單向鏈表。 // 也因此,我們才能推斷出Hashtable是由拉鏈法實現的散列表 private static class Entry<K,V> implements Map.Entry<K,V> { // 哈希值 int hash; K key; V value; // 指向的下一個Entry,即鏈表的下一個節點 Entry<K,V> next; // 構造函數 protected Entry(int hash, K key, V value, Entry<K,V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } protected Object clone() { return new Entry<K,V>(hash, key, value, (next==null ? null : (Entry<K,V>) next.clone())); } public K getKey() { return key; } public V getValue() { return value; } // 設置value。若value是null,則拋出異常。 public V setValue(V value) { if (value == null) throw new NullPointerException(); V oldValue = this.value; this.value = value; return oldValue; } // 覆蓋equals()方法,判斷兩個Entry是否相等。 // 若兩個Entry的key和value都相等,則認為它們相等。 public boolean equals(Object o) { if (!(o instanceof Map.Entry)) return false; Map.Entry e = (Map.Entry)o; return (key==null ? e.getKey()==null : key.equals(e.getKey())) && (value==null ? e.getValue()==null : value.equals(e.getValue())); } public int hashCode() { return hash ^ (value==null ? 0 : value.hashCode()); } public String toString() { return key.toString()+"="+value.toString(); } } private static final int KEYS = 0; private static final int VALUES = 1; private static final int ENTRIES = 2; // Enumerator的作用是提供了“通過elements()遍歷Hashtable的接口” 和 “通過entrySet()遍歷Hashtable的接口”。因為,它同時實現了 “Enumerator接口”和“Iterator接口”。 private class Enumerator<T> implements Enumeration<T>, Iterator<T> { // 指向Hashtable的table Entry[] table = Hashtable.this.table; // Hashtable的總的大小 int index = table.length; Entry<K,V> entry = null; Entry<K,V> lastReturned = null; int type; // Enumerator是 “迭代器(Iterator)” 還是 “枚舉類(Enumeration)”的標志 // iterator為true,表示它是迭代器;否則,是枚舉類。 boolean iterator; // 在將Enumerator當作迭代器使用時會用到,用來實現fail-fast機制。 protected int expectedModCount = modCount; Enumerator(int type, boolean iterator) { this.type = type; this.iterator = iterator; } // 從遍歷table的數組的末尾向前查找,直到找到不為null的Entry。 public boolean hasMoreElements() { Entry<K,V> e = entry; int i = index; Entry[] t = table; /* Use locals for faster loop iteration */ while (e == null && i > 0) { e = t[--i]; } entry = e; index = i; return e != null; } // 獲取下一個元素 // 注意:從hasMoreElements() 和nextElement() 可以看出“Hashtable的elements()遍歷方式” // 首先,從後向前的遍歷table數組。table數組的每個節點都是一個單向鏈表(Entry)。 // 然後,依次向後遍歷單向鏈表Entry。 public T nextElement() { Entry<K,V> et = entry; int i = index; Entry[] t = table; /* Use locals for faster loop iteration */ while (et == null && i > 0) { et = t[--i]; } entry = et; index = i; if (et != null) { Entry<K,V> e = lastReturned = entry; entry = e.next; return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e); } throw new NoSuchElementException("Hashtable Enumerator"); } // 迭代器Iterator的判斷是否存在下一個元素 // 實際上,它是調用的hasMoreElements() public boolean hasNext() { return hasMoreElements(); } // 迭代器獲取下一個元素 // 實際上,它是調用的nextElement() public T next() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); return nextElement(); } // 迭代器的remove()接口。 // 首先,它在table數組中找出要刪除元素所在的Entry, // 然後,刪除單向鏈表Entry中的元素。 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; for (Entry<K,V> e = tab[index], 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(); } } } private static Enumeration emptyEnumerator = new EmptyEnumerator(); private static Iterator emptyIterator = new EmptyIterator(); // 空枚舉類 // 當Hashtable的實際大小為0;此時,又要通過Enumeration遍歷Hashtable時,返回的是“空枚舉類”的對象。 private static class EmptyEnumerator implements Enumeration<Object> { EmptyEnumerator() { } // 空枚舉類的hasMoreElements() 始終返回false public boolean hasMoreElements() { return false; } // 空枚舉類的nextElement() 拋出異常 public Object nextElement() { throw new NoSuchElementException("Hashtable Enumerator"); } } // 空迭代器 // 當Hashtable的實際大小為0;此時,又要通過迭代器遍歷Hashtable時,返回的是“空迭代器”的對象。 private static class EmptyIterator implements Iterator<Object> { EmptyIterator() { } public boolean hasNext() { return false; } public Object next() { throw new NoSuchElementException("Hashtable Iterator"); } public void remove() { throw new IllegalStateException("Hashtable Iterator"); } } }
說明:
在詳細介紹Hashtable的代碼之前,我們需要了解:和Hashmap一樣,Hashtable也是一個散列表,它也是通過“拉鏈法”解決哈希沖突的。
第2.1部分 Hashtable的“拉鏈法”相關內容
2.1.1 Hashtable數據存儲數組
private transient Entry[] table;
Hashtable中的key-value都是存儲在table數組中的。
2.1.2 數據節點Entry的數據結構
private static class Entry<K,V> implements Map.Entry<K,V> { // 哈希值 int hash; K key; V value; // 指向的下一個Entry,即鏈表的下一個節點 Entry<K,V> next; // 構造函數 protected Entry(int hash, K key, V value, Entry<K,V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } protected Object clone() { return new Entry<K,V>(hash, key, value, (next==null ? null : (Entry<K,V>) next.clone())); } public K getKey() { return key; } public V getValue() { return value; } // 設置value。若value是null,則拋出異常。 public V setValue(V value) { if (value == null) throw new NullPointerException(); V oldValue = this.value; this.value = value; return oldValue; } // 覆蓋equals()方法,判斷兩個Entry是否相等。 // 若兩個Entry的key和value都相等,則認為它們相等。 public boolean equals(Object o) { if (!(o instanceof Map.Entry)) return false; Map.Entry e = (Map.Entry)o; return (key==null ? e.getKey()==null : key.equals(e.getKey())) && (value==null ? e.getValue()==null : value.equals(e.getValue())); } public int hashCode() { return hash ^ (value==null ? 0 : value.hashCode()); } public String toString() { return key.toString()+"="+value.toString(); } }
從中,我們可以看出 Entry 實際上就是一個單向鏈表。這也是為什麼我們說Hashtable是通過拉鏈法解決哈希沖突的。
Entry 實現了Map.Entry 接口,即實現getKey(), getValue(), setValue(V value), equals(Object o), hashCode()這些函數。這些都是基本的讀取/修改key、value值的函數。
第2.2部分 Hashtable的構造函數
Hashtable共包括4個構造函數
// 默認構造函數。 public Hashtable() { // 默認構造函數,指定的容量大小是11;加載因子是0.75 this(11, 0.75f); } // 指定“容量大小”的構造函數 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)(initialCapacity * loadFactor); } // 包含“子Map”的構造函數 public Hashtable(Map<? extends K, ? extends V> t) { this(Math.max(2*t.size(), 11), 0.75f); // 將“子Map”的全部元素都添加到Hashtable中 putAll(t); }
第2.3部分 Hashtable的主要對外接口
2.3.1 clear()
clear() 的作用是清空Hashtable。它是將Hashtable的table數組的值全部設為null
public synchronized void clear() { Entry tab[] = table; modCount++; for (int index = tab.length; --index >= 0; ) tab[index] = null; count = 0; }
2.3.2 contains() 和 containsValue()
contains() 和 containsValue() 的作用都是判斷Hashtable是否包含“值(value)”
public boolean containsValue(Object value) { return contains(value); } public synchronized boolean contains(Object value) { // Hashtable中“鍵值對”的value不能是null, // 若是null的話,拋出異常! if (value == null) { throw new NullPointerException(); } // 從後向前遍歷table數組中的元素(Entry) // 對於每個Entry(單向鏈表),逐個遍歷,判斷節點的值是否等於value Entry tab[] = table; for (int i = tab.length ; i-- > 0 ;) { for (Entry<K,V> e = tab[i] ; e != null ; e = e.next) { if (e.value.equals(value)) { return true; } } } return false; }
2.3.3 containsKey()
containsKey() 的作用是判斷Hashtable是否包含key
public synchronized boolean containsKey(Object key) { Entry tab[] = table; int hash = key.hashCode(); // 計算索引值, // % tab.length 的目的是防止數據越界 int index = (hash & 0x7FFFFFFF) % tab.length; // 找到“key對應的Entry(鏈表)”,然後在鏈表中找出“哈希值”和“鍵值”與key都相等的元素 for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) { if ((e.hash == hash) && e.key.equals(key)) { return true; } } return false; }
2.3.4 elements()
elements() 的作用是返回“所有value”的枚舉對象
public synchronized Enumeration<V> elements() { return this.<V>getEnumeration(VALUES); } // 獲取Hashtable的枚舉類對象 private <T> Enumeration<T> getEnumeration(int type) { if (count == 0) { return (Enumeration<T>)emptyEnumerator; } else { return new Enumerator<T>(type, false); } }
從中,我們可以看出:
(01) 若Hashtable的實際大小為0,則返回“空枚舉類”對象emptyEnumerator;
(02) 否則,返回正常的Enumerator的對象。(Enumerator實現了迭代器和枚舉兩個接口)
我們先看看emptyEnumerator對象是如何實現的
private static Enumeration emptyEnumerator = new EmptyEnumerator(); // 空枚舉類 // 當Hashtable的實際大小為0;此時,又要通過Enumeration遍歷Hashtable時,返回的是“空枚舉類”的對象。 private static class EmptyEnumerator implements Enumeration<Object> { EmptyEnumerator() { } // 空枚舉類的hasMoreElements() 始終返回false public boolean hasMoreElements() { return false; } // 空枚舉類的nextElement() 拋出異常 public Object nextElement() { throw new NoSuchElementException("Hashtable Enumerator"); } }
我們在來看看Enumeration類
Enumerator的作用是提供了“通過elements()遍歷Hashtable的接口” 和 “通過entrySet()遍歷Hashtable的接口”。因為,它同時實現了 “Enumerator接口”和“Iterator接口”。
private class Enumerator<T> implements Enumeration<T>, Iterator<T> { // 指向Hashtable的table Entry[] table = Hashtable.this.table; // Hashtable的總的大小 int index = table.length; Entry<K,V> entry = null; Entry<K,V> lastReturned = null; int type; // Enumerator是 “迭代器(Iterator)” 還是 “枚舉類(Enumeration)”的標志 // iterator為true,表示它是迭代器;否則,是枚舉類。 boolean iterator; // 在將Enumerator當作迭代器使用時會用到,用來實現fail-fast機制。 protected int expectedModCount = modCount; Enumerator(int type, boolean iterator) { this.type = type; this.iterator = iterator; } // 從遍歷table的數組的末尾向前查找,直到找到不為null的Entry。 public boolean hasMoreElements() { Entry<K,V> e = entry; int i = index; Entry[] t = table; /* Use locals for faster loop iteration */ while (e == null && i > 0) { e = t[--i]; } entry = e; index = i; return e != null; } // 獲取下一個元素 // 注意:從hasMoreElements() 和nextElement() 可以看出“Hashtable的elements()遍歷方式” // 首先,從後向前的遍歷table數組。table數組的每個節點都是一個單向鏈表(Entry)。 // 然後,依次向後遍歷單向鏈表Entry。 public T nextElement() { Entry<K,V> et = entry; int i = index; Entry[] t = table; /* Use locals for faster loop iteration */ while (et == null && i > 0) { et = t[--i]; } entry = et; index = i; if (et != null) { Entry<K,V> e = lastReturned = entry; entry = e.next; return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e); } throw new NoSuchElementException("Hashtable Enumerator"); } // 迭代器Iterator的判斷是否存在下一個元素 // 實際上,它是調用的hasMoreElements() public boolean hasNext() { return hasMoreElements(); } // 迭代器獲取下一個元素 // 實際上,它是調用的nextElement() public T next() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); return nextElement(); } // 迭代器的remove()接口。 // 首先,它在table數組中找出要刪除元素所在的Entry, // 然後,刪除單向鏈表Entry中的元素。 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; for (Entry<K,V> e = tab[index], 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(); } } }
entrySet(), keySet(), keys(), values()的實現方法和elements()差不多,而且源碼中已經明確的給出了注釋。這裡就不再做過多說明了。
2.3.5 get()
get() 的作用就是獲取key對應的value,沒有的話返回null
public synchronized V get(Object key) { Entry tab[] = table; int hash = key.hashCode(); // 計算索引值, int index = (hash & 0x7FFFFFFF) % tab.length; // 找到“key對應的Entry(鏈表)”,然後在鏈表中找出“哈希值”和“鍵值”與key都相等的元素 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; }
2.3.6 put()
put() 的作用是對外提供接口,讓Hashtable對象可以通過put()將“key-value”添加到Hashtable中。
public synchronized V put(K key, V value) { // Hashtable中不能插入value為null的元素!!! if (value == null) { throw new NullPointerException(); } // 若“Hashtable中已存在鍵為key的鍵值對”, // 則用“新的value”替換“舊的value” Entry tab[] = table; int hash = key.hashCode(); 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; } } // 若“Hashtable中不存在鍵為key的鍵值對”, // (01) 將“修改統計數”+1 modCount++; // (02) 若“Hashtable實際容量” > “阈值”(阈值=總的容量 * 加載因子) // 則調整Hashtable的大小 if (count >= threshold) { // Rehash the table if the threshold is exceeded rehash(); tab = table; index = (hash & 0x7FFFFFFF) % tab.length; } // (03) 將“Hashtable中index”位置的Entry(鏈表)保存到e中 Entry<K,V> e = tab[index]; // (04) 創建“新的Entry節點”,並將“新的Entry”插入“Hashtable的index位置”,並設置e為“新的Entry”的下一個元素(即“新Entry”為鏈表表頭)。 tab[index] = new Entry<K,V>(hash, key, value, e); // (05) 將“Hashtable的實際容量”+1 count++; return null; }
2.3.7 putAll()
putAll() 的作用是將“Map(t)”的中全部元素逐一添加到Hashtable中
1 public synchronized void putAll(Map<? extends K, ? extends V> t) {
2 for (Map.Entry<? extends K, ? extends V> e : t.entrySet())
3 put(e.getKey(), e.getValue());
4 }
2.3.8 remove()
remove() 的作用就是刪除Hashtable中鍵為key的元素
public synchronized V remove(Object key) { Entry tab[] = table; int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; // 找到“key對應的Entry(鏈表)” // 然後在鏈表中找出要刪除的節點,並刪除該節點。 for (Entry<K,V> e = tab[index], 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; }
第2.4部分 Hashtable實現的Cloneable接口
Hashtable實現了Cloneable接口,即實現了clone()方法。
clone()方法的作用很簡單,就是克隆一個Hashtable對象並返回。
// 克隆一個Hashtable,並以Object的形式返回。 public synchronized Object clone() { try { Hashtable<K,V> t = (Hashtable<K,V>) super.clone(); t.table = new Entry[table.length]; for (int i = table.length ; i-- > 0 ; ) { t.table[i] = (table[i] != null) ? (Entry<K,V>) table[i].clone() : null; } t.keySet = null; t.entrySet = null; t.values = null; t.modCount = 0; return t; } catch (CloneNotSupportedException e) { // this shouldn't happen, since we are Cloneable throw new InternalError(); } }
第2.5部分 Hashtable實現的Serializable接口
Hashtable實現java.io.Serializable,分別實現了串行讀取、寫入功能。
串行寫入函數就是將Hashtable的“總的容量,實際容量,所有的Entry”都寫入到輸出流中
串行讀取函數:根據寫入方式讀出將Hashtable的“總的容量,實際容量,所有的Entry”依次讀出
private synchronized void writeObject(java.io.ObjectOutputStream s) throws IOException { // Write out the length, threshold, loadfactor s.defaultWriteObject(); // Write out length, count of elements and then the key/value objects s.writeInt(table.length); s.writeInt(count); for (int index = table.length-1; index >= 0; index--) { Entry entry = table[index]; while (entry != null) { s.writeObject(entry.key); s.writeObject(entry.value); entry = entry.next; } } } private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException { // Read in the length, threshold, and loadfactor s.defaultReadObject(); // Read the original length of the array and number of elements int origlength = s.readInt(); int elements = s.readInt(); // Compute new size with a bit of room 5% to grow but // no larger than the original size. 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 * loadFactor) + (elements / 20) + 3; if (length > elements && (length & 1) == 0) length--; if (origlength > 0 && length > origlength) length = origlength; Entry[] table = new Entry[length]; count = 0; // Read the number of elements and then all the key/value objects for (; elements > 0; elements--) { K key = (K)s.readObject(); V value = (V)s.readObject(); // synch could be eliminated for performance reconstitutionPut(table, key, value); } this.table = table; }
第3部分 Hashtable遍歷方式
3.1 遍歷Hashtable的鍵值對
第一步:根據entrySet()獲取Hashtable的“鍵值對”的Set集合。
第二步:通過Iterator迭代器遍歷“第一步”得到的集合。
// 假設table是Hashtable對象 // table中的key是String類型,value是Integer類型 Integer integ = null; Iterator iter = table.entrySet().iterator(); while(iter.hasNext()) { Map.Entry entry = (Map.Entry)iter.next(); // 獲取key key = (String)entry.getKey(); // 獲取value integ = (Integer)entry.getValue(); }
3.2 通過Iterator遍歷Hashtable的鍵
第一步:根據keySet()獲取Hashtable的“鍵”的Set集合。
第二步:通過Iterator迭代器遍歷“第一步”得到的集合。
// 假設table是Hashtable對象 // table中的key是String類型,value是Integer類型 String key = null; Integer integ = null; Iterator iter = table.keySet().iterator(); while (iter.hasNext()) { // 獲取key key = (String)iter.next(); // 根據key,獲取value integ = (Integer)table.get(key); }
3.3 通過Iterator遍歷Hashtable的值
第一步:根據value()獲取Hashtable的“值”的集合。
第二步:通過Iterator迭代器遍歷“第一步”得到的集合。
// 假設table是Hashtable對象 // table中的key是String類型,value是Integer類型 Integer value = null; Collection c = table.values(); Iterator iter= c.iterator(); while (iter.hasNext()) { value = (Integer)iter.next(); }
3.4 通過Enumeration遍歷Hashtable的鍵
第一步:根據keys()獲取Hashtable的集合。
第二步:通過Enumeration遍歷“第一步”得到的集合。
Enumeration enu = table.keys();
while(enu.hasMoreElements()) {
System.out.println(enu.nextElement());
}
3.5 通過Enumeration遍歷Hashtable的值
第一步:根據elements()獲取Hashtable的集合。
第二步:通過Enumeration遍歷“第一步”得到的集合。
Enumeration enu = table.elements();
while(enu.hasMoreElements()) {
System.out.println(enu.nextElement());
}
遍歷測試程序如下:
import java.util.*; /* * @desc 遍歷Hashtable的測試程序。 * (01) 通過entrySet()去遍歷key、value,參考實現函數: * iteratorHashtableByEntryset() * (02) 通過keySet()去遍歷key,參考實現函數: * iteratorHashtableByKeyset() * (03) 通過values()去遍歷value,參考實現函數: * iteratorHashtableJustValues() * (04) 通過Enumeration去遍歷key,參考實現函數: * enumHashtableKey() * (05) 通過Enumeration去遍歷value,參考實現函數: * enumHashtableValue() * * @author skywang */ public class HashtableIteratorTest { public static void main(String[] args) { int val = 0; String key = null; Integer value = null; Random r = new Random(); Hashtable table = new Hashtable(); for (int i=0; i<12; i++) { // 隨機獲取一個[0,100)之間的數字 val = r.nextInt(100); key = String.valueOf(val); value = r.nextInt(5); // 添加到Hashtable中 table.put(key, value); System.out.println(" key:"+key+" value:"+value); } // 通過entrySet()遍歷Hashtable的key-value iteratorHashtableByEntryset(table) ; // 通過keySet()遍歷Hashtable的key-value iteratorHashtableByKeyset(table) ; // 單單遍歷Hashtable的value iteratorHashtableJustValues(table); // 遍歷Hashtable的Enumeration的key enumHashtableKey(table); // 遍歷Hashtable的Enumeration的value //enumHashtableValue(table); } /* * 通過Enumeration遍歷Hashtable的key * 效率高! */ private static void enumHashtableKey(Hashtable table) { if (table == null) return ; System.out.println("\nenumeration Hashtable"); Enumeration enu = table.keys(); while(enu.hasMoreElements()) { System.out.println(enu.nextElement()); } } /* * 通過Enumeration遍歷Hashtable的value * 效率高! */ private static void enumHashtableValue(Hashtable table) { if (table == null) return ; System.out.println("\nenumeration Hashtable"); Enumeration enu = table.elements(); while(enu.hasMoreElements()) { System.out.println(enu.nextElement()); } } /* * 通過entry set遍歷Hashtable * 效率高! */ private static void iteratorHashtableByEntryset(Hashtable table) { if (table == null) return ; System.out.println("\niterator Hashtable By entryset"); String key = null; Integer integ = null; Iterator iter = table.entrySet().iterator(); while(iter.hasNext()) { Map.Entry entry = (Map.Entry)iter.next(); key = (String)entry.getKey(); integ = (Integer)entry.getValue(); System.out.println(key+" -- "+integ.intValue()); } } /* * 通過keyset來遍歷Hashtable * 效率低! */ private static void iteratorHashtableByKeyset(Hashtable table) { if (table == null) return ; System.out.println("\niterator Hashtable By keyset"); String key = null; Integer integ = null; Iterator iter = table.keySet().iterator(); while (iter.hasNext()) { key = (String)iter.next(); integ = (Integer)table.get(key); System.out.println(key+" -- "+integ.intValue()); } } /* * 遍歷Hashtable的values */ private static void iteratorHashtableJustValues(Hashtable table) { if (table == null) return ; Collection c = table.values(); Iterator iter= c.iterator(); while (iter.hasNext()) { System.out.println(iter.next()); } } }
第4部分 Hashtable示例
下面通過一個實例來學習如何使用Hashtable
import java.util.*; /* * @desc Hashtable的測試程序。 * * @author skywang */ public class HashtableTest { public static void main(String[] args) { testHashtableAPIs(); } private static void testHashtableAPIs() { // 初始化隨機種子 Random r = new Random(); // 新建Hashtable Hashtable table = new Hashtable(); // 添加操作 table.put("one", r.nextInt(10)); table.put("two", r.nextInt(10)); table.put("three", r.nextInt(10)); // 打印出table System.out.println("table:"+table ); // 通過Iterator遍歷key-value Iterator iter = table.entrySet().iterator(); while(iter.hasNext()) { Map.Entry entry = (Map.Entry)iter.next(); System.out.println("next : "+ entry.getKey() +" - "+entry.getValue()); } // Hashtable的鍵值對個數 System.out.println("size:"+table.size()); // containsKey(Object key) :是否包含鍵key System.out.println("contains key two : "+table.containsKey("two")); System.out.println("contains key five : "+table.containsKey("five")); // containsValue(Object value) :是否包含值value System.out.println("contains value 0 : "+table.containsValue(new Integer(0))); // remove(Object key) : 刪除鍵key對應的鍵值對 table.remove("three"); System.out.println("table:"+table ); // clear() : 清空Hashtable table.clear(); // isEmpty() : Hashtable是否為空 System.out.println((table.isEmpty()?"table is empty":"table is not empty") ); } }