Hashtable源码剖析

Hashtable简介

    Hashtable同样是基于哈希表实现的,同样每个元素是一个key-value对,其内部也是通过单链表解决冲突问题,容量不足(超过了阀值)时,同样会自动增长。

    Hashtable也是JDK1.0引入的类,是线程安全的,能用于多线程环境中。

    Hashtable同样实现了Serializable接口,它支持序列化,实现了Cloneable接口,能被克隆。

HashTable源码剖析

    Hashtable的源码的很多实现都与HashMap差不多,源码如下(加入了比较详细的注释):

  1 package java.util;    
  2 import java.io.*;    
  3    
  4 public class Hashtable<K,V>    
  5     extends Dictionary<K,V>    
  6     implements Map<K,V>, Cloneable, java.io.Serializable {    
  7    
  8     // 保存key-value的数组。    
  9     // Hashtable同样采用单链表解决冲突,每一个Entry本质上是一个单向链表    
 10     private transient Entry[] table;    
 11    
 12     // Hashtable中键值对的数量    
 13     private transient int count;    
 14    
 15     // 阈值,用于判断是否需要调整Hashtable的容量(threshold = 容量*加载因子)    
 16     private int threshold;    
 17    
 18     // 加载因子    
 19     private float loadFactor;    
 20    
 21     // Hashtable被改变的次数,用于fail-fast机制的实现    
 22     private transient int modCount = 0;    
 23    
 24     // 序列版本号    
 25     private static final long serialVersionUID = 1421746759512286392L;    
 26    
 27     // 指定“容量大小”和“加载因子”的构造函数    
 28     public Hashtable(int initialCapacity, float loadFactor) {    
 29         if (initialCapacity < 0)    
 30             throw new IllegalArgumentException("Illegal Capacity: "+    
 31                                                initialCapacity);    
 32         if (loadFactor <= 0 || Float.isNaN(loadFactor))    
 33             throw new IllegalArgumentException("Illegal Load: "+loadFactor);    
 34    
 35         if (initialCapacity==0)    
 36             initialCapacity = 1;    
 37         this.loadFactor = loadFactor;    
 38         table = new Entry[initialCapacity];    
 39         threshold = (int)(initialCapacity * loadFactor);    
 40     }    
 41    
 42     // 指定“容量大小”的构造函数    
 43     public Hashtable(int initialCapacity) {    
 44         this(initialCapacity, 0.75f);    
 45     }    
 46    
 47     // 默认构造函数。    
 48     public Hashtable() {    
 49         // 默认构造函数,指定的容量大小是11;加载因子是0.75    
 50         this(11, 0.75f);    
 51     }    
 52    
 53     // 包含“子Map”的构造函数    
 54     public Hashtable(Map<? extends K, ? extends V> t) {    
 55         this(Math.max(2*t.size(), 11), 0.75f);    
 56         // 将“子Map”的全部元素都添加到Hashtable中    
 57         putAll(t);    
 58     }    
 59    
 60     public synchronized int size() {    
 61         return count;    
 62     }    
 63    
 64     public synchronized boolean isEmpty() {    
 65         return count == 0;    
 66     }    
 67    
 68     // 返回“所有key”的枚举对象    
 69     public synchronized Enumeration<K> keys() {    
 70         return this.<K>getEnumeration(KEYS);    
 71     }    
 72    
 73     // 返回“所有value”的枚举对象    
 74     public synchronized Enumeration<V> elements() {    
 75         return this.<V>getEnumeration(VALUES);    
 76     }    
 77    
 78     // 判断Hashtable是否包含“值(value)”    
 79     public synchronized boolean contains(Object value) {    
 80         //注意,Hashtable中的value不能是null,    
 81         // 若是null的话,抛出异常!    
 82         if (value == null) {    
 83             throw new NullPointerException();    
 84         }    
 85    
 86         // 从后向前遍历table数组中的元素(Entry)    
 87         // 对于每个Entry(单向链表),逐个遍历,判断节点的值是否等于value    
 88         Entry tab[] = table;    
 89         for (int i = tab.length ; i-- > 0 ;) {    
 90             for (Entry<K,V> e = tab[i] ; e != null ; e = e.next) {    
 91                 if (e.value.equals(value)) {    
 92                     return true;    
 93                 }    
 94             }    
 95         }    
 96         return false;    
 97     }    
 98    
 99     public boolean containsValue(Object value) {    
100         return contains(value);    
101     }    
102    
103     // 判断Hashtable是否包含key    
104     public synchronized boolean containsKey(Object key) {    
105         Entry tab[] = table;    
106         //计算hash值,直接用key的hashCode代替  
107         int hash = key.hashCode();      
108         // 计算在数组中的索引值   
109         int index = (hash & 0x7FFFFFFF) % tab.length;    
110         // 找到“key对应的Entry(链表)”,然后在链表中找出“哈希值”和“键值”与key都相等的元素    
111         for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {    
112             if ((e.hash == hash) && e.key.equals(key)) {    
113                 return true;    
114             }    
115         }    
116         return false;    
117     }    
118    
119     // 返回key对应的value,没有的话返回null    
120     public synchronized V get(Object key) {    
121         Entry tab[] = table;    
122         int hash = key.hashCode();    
123         // 计算索引值,    
124         int index = (hash & 0x7FFFFFFF) % tab.length;    
125         // 找到“key对应的Entry(链表)”,然后在链表中找出“哈希值”和“键值”与key都相等的元素    
126         for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {    
127             if ((e.hash == hash) && e.key.equals(key)) {    
128                 return e.value;    
129             }    
130         }    
131         return null;    
132     }    
133    
134     // 调整Hashtable的长度,将长度变成原来的2倍+1   
135     protected void rehash() {    
136         int oldCapacity = table.length;    
137         Entry[] oldMap = table;    
138    
139         //创建新容量大小的Entry数组  
140         int newCapacity = oldCapacity * 2 + 1;    
141         Entry[] newMap = new Entry[newCapacity];    
142    
143         modCount++;    
144         threshold = (int)(newCapacity * loadFactor);    
145         table = newMap;    
146           
147         //将“旧的Hashtable”中的元素复制到“新的Hashtable”中  
148         for (int i = oldCapacity ; i-- > 0 ;) {    
149             for (Entry<K,V> old = oldMap[i] ; old != null ; ) {    
150                 Entry<K,V> e = old;    
151                 old = old.next;    
152                 //重新计算index  
153                 int index = (e.hash & 0x7FFFFFFF) % newCapacity;    
154                 e.next = newMap[index];    
155                 newMap[index] = e;    
156             }    
157         }    
158     }    
159    
160     // 将“key-value”添加到Hashtable中    
161     public synchronized V put(K key, V value) {    
162         // Hashtable中不能插入value为null的元素!!!    
163         if (value == null) {    
164             throw new NullPointerException();    
165         }    
166    
167         // 若“Hashtable中已存在键为key的键值对”,    
168         // 则用“新的value”替换“旧的value”    
169         Entry tab[] = table;    
170         int hash = key.hashCode();    
171         int index = (hash & 0x7FFFFFFF) % tab.length;    
172         for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {    
173             if ((e.hash == hash) && e.key.equals(key)) {    
174                 V old = e.value;    
175                 e.value = value;    
176                 return old;    
177                 }    
178         }    
179    
180         // 若“Hashtable中不存在键为key的键值对”,  
181         // 将“修改统计数”+1    
182         modCount++;    
183         //  若“Hashtable实际容量” > “阈值”(阈值=总的容量 * 加载因子)    
184         //  则调整Hashtable的大小    
185         if (count >= threshold) {  
186             rehash();    
187    
188             tab = table;    
189             index = (hash & 0x7FFFFFFF) % tab.length;    
190         }    
191    
192         //将新的key-value对插入到tab[index]处(即链表的头结点)  
193         Entry<K,V> e = tab[index];           
194         tab[index] = new Entry<K,V>(hash, key, value, e);    
195         count++;    
196         return null;    
197     }    
198    
199     // 删除Hashtable中键为key的元素    
200     public synchronized V remove(Object key) {    
201         Entry tab[] = table;    
202         int hash = key.hashCode();    
203         int index = (hash & 0x7FFFFFFF) % tab.length;    
204           
205         //从table[index]链表中找出要删除的节点,并删除该节点。  
206         //因为是单链表,因此要保留带删节点的前一个节点,才能有效地删除节点  
207         for (Entry<K,V> e = tab[index], prev = null ; e != null ; prev = e, e = e.next) {    
208             if ((e.hash == hash) && e.key.equals(key)) {    
209                 modCount++;    
210                 if (prev != null) {    
211                     prev.next = e.next;    
212                 } else {    
213                     tab[index] = e.next;    
214                 }    
215                 count--;    
216                 V oldValue = e.value;    
217                 e.value = null;    
218                 return oldValue;    
219             }    
220         }    
221         return null;    
222     }    
223    
224     // 将“Map(t)”的中全部元素逐一添加到Hashtable中    
225     public synchronized void putAll(Map<? extends K, ? extends V> t) {    
226         for (Map.Entry<? extends K, ? extends V> e : t.entrySet())    
227             put(e.getKey(), e.getValue());    
228     }    
229    
230     // 清空Hashtable    
231     // 将Hashtable的table数组的值全部设为null    
232     public synchronized void clear() {    
233         Entry tab[] = table;    
234         modCount++;    
235         for (int index = tab.length; --index >= 0; )    
236             tab[index] = null;    
237         count = 0;    
238     }    
239    
240     // 克隆一个Hashtable,并以Object的形式返回。    
241     public synchronized Object clone() {    
242         try {    
243             Hashtable<K,V> t = (Hashtable<K,V>) super.clone();    
244             t.table = new Entry[table.length];    
245             for (int i = table.length ; i-- > 0 ; ) {    
246                 t.table[i] = (table[i] != null)    
247                 ? (Entry<K,V>) table[i].clone() : null;    
248             }    
249             t.keySet = null;    
250             t.entrySet = null;    
251             t.values = null;    
252             t.modCount = 0;    
253             return t;    
254         } catch (CloneNotSupportedException e) {     
255             throw new InternalError();    
256         }    
257     }    
258    
259     public synchronized String toString() {    
260         int max = size() - 1;    
261         if (max == -1)    
262             return "{}";    
263    
264         StringBuilder sb = new StringBuilder();    
265         Iterator<Map.Entry<K,V>> it = entrySet().iterator();    
266    
267         sb.append('{');    
268         for (int i = 0; ; i++) {    
269             Map.Entry<K,V> e = it.next();    
270             K key = e.getKey();    
271             V value = e.getValue();    
272             sb.append(key   == this ? "(this Map)" : key.toString());    
273             sb.append('=');    
274             sb.append(value == this ? "(this Map)" : value.toString());    
275    
276             if (i == max)    
277                 return sb.append('}').toString();    
278             sb.append(", ");    
279         }    
280     }    
281    
282     // 获取Hashtable的枚举类对象    
283     // 若Hashtable的实际大小为0,则返回“空枚举类”对象;    
284     // 否则,返回正常的Enumerator的对象。   
285     private <T> Enumeration<T> getEnumeration(int type) {    
286     if (count == 0) {    
287         return (Enumeration<T>)emptyEnumerator;    
288     } else {    
289         return new Enumerator<T>(type, false);    
290     }    
291     }    
292    
293     // 获取Hashtable的迭代器    
294     // 若Hashtable的实际大小为0,则返回“空迭代器”对象;    
295     // 否则,返回正常的Enumerator的对象。(Enumerator实现了迭代器和枚举两个接口)    
296     private <T> Iterator<T> getIterator(int type) {    
297         if (count == 0) {    
298             return (Iterator<T>) emptyIterator;    
299         } else {    
300             return new Enumerator<T>(type, true);    
301         }    
302     }    
303    
304     // Hashtable的“key的集合”。它是一个Set,没有重复元素    
305     private transient volatile Set<K> keySet = null;    
306     // Hashtable的“key-value的集合”。它是一个Set,没有重复元素    
307     private transient volatile Set<Map.Entry<K,V>> entrySet = null;    
308     // Hashtable的“key-value的集合”。它是一个Collection,可以有重复元素    
309     private transient volatile Collection<V> values = null;    
310    
311     // 返回一个被synchronizedSet封装后的KeySet对象    
312     // synchronizedSet封装的目的是对KeySet的所有方法都添加synchronized,实现多线程同步    
313     public Set<K> keySet() {    
314         if (keySet == null)    
315             keySet = Collections.synchronizedSet(new KeySet(), this);    
316         return keySet;    
317     }    
318    
319     // Hashtable的Key的Set集合。    
320     // KeySet继承于AbstractSet,所以,KeySet中的元素没有重复的。    
321     private class KeySet extends AbstractSet<K> {    
322         public Iterator<K> iterator() {    
323             return getIterator(KEYS);    
324         }    
325         public int size() {    
326             return count;    
327         }    
328         public boolean contains(Object o) {    
329             return containsKey(o);    
330         }    
331         public boolean remove(Object o) {    
332             return Hashtable.this.remove(o) != null;    
333         }    
334         public void clear() {    
335             Hashtable.this.clear();    
336         }    
337     }    
338    
339     // 返回一个被synchronizedSet封装后的EntrySet对象    
340     // synchronizedSet封装的目的是对EntrySet的所有方法都添加synchronized,实现多线程同步    
341     public Set<Map.Entry<K,V>> entrySet() {    
342         if (entrySet==null)    
343             entrySet = Collections.synchronizedSet(new EntrySet(), this);    
344         return entrySet;    
345     }    
346    
347     // Hashtable的Entry的Set集合。    
348     // EntrySet继承于AbstractSet,所以,EntrySet中的元素没有重复的。    
349     private class EntrySet extends AbstractSet<Map.Entry<K,V>> {    
350         public Iterator<Map.Entry<K,V>> iterator() {    
351             return getIterator(ENTRIES);    
352         }    
353    
354         public boolean add(Map.Entry<K,V> o) {    
355             return super.add(o);    
356         }    
357    
358         // 查找EntrySet中是否包含Object(0)    
359         // 首先,在table中找到o对应的Entry链表    
360         // 然后,查找Entry链表中是否存在Object    
361         public boolean contains(Object o) {    
362             if (!(o instanceof Map.Entry))    
363                 return false;    
364             Map.Entry entry = (Map.Entry)o;    
365             Object key = entry.getKey();    
366             Entry[] tab = table;    
367             int hash = key.hashCode();    
368             int index = (hash & 0x7FFFFFFF) % tab.length;    
369    
370             for (Entry e = tab[index]; e != null; e = e.next)    
371                 if (e.hash==hash && e.equals(entry))    
372                     return true;    
373             return false;    
374         }    
375    
376         // 删除元素Object(0)    
377         // 首先,在table中找到o对应的Entry链表  
378         // 然后,删除链表中的元素Object    
379         public boolean remove(Object o) {    
380             if (!(o instanceof Map.Entry))    
381                 return false;    
382             Map.Entry<K,V> entry = (Map.Entry<K,V>) o;    
383             K key = entry.getKey();    
384             Entry[] tab = table;    
385             int hash = key.hashCode();    
386             int index = (hash & 0x7FFFFFFF) % tab.length;    
387    
388             for (Entry<K,V> e = tab[index], prev = null; e != null;    
389                  prev = e, e = e.next) {    
390                 if (e.hash==hash && e.equals(entry)) {    
391                     modCount++;    
392                     if (prev != null)    
393                         prev.next = e.next;    
394                     else   
395                         tab[index] = e.next;    
396    
397                     count--;    
398                     e.value = null;    
399                     return true;    
400                 }    
401             }    
402             return false;    
403         }    
404    
405         public int size() {    
406             return count;    
407         }    
408    
409         public void clear() {    
410             Hashtable.this.clear();    
411         }    
412     }    
413    
414     // 返回一个被synchronizedCollection封装后的ValueCollection对象    
415     // synchronizedCollection封装的目的是对ValueCollection的所有方法都添加synchronized,实现多线程同步    
416     public Collection<V> values() {    
417     if (values==null)    
418         values = Collections.synchronizedCollection(new ValueCollection(),    
419                                                         this);    
420         return values;    
421     }    
422    
423     // Hashtable的value的Collection集合。    
424     // ValueCollection继承于AbstractCollection,所以,ValueCollection中的元素可以重复的。    
425     private class ValueCollection extends AbstractCollection<V> {    
426         public Iterator<V> iterator() {    
427         return getIterator(VALUES);    
428         }    
429         public int size() {    
430             return count;    
431         }    
432         public boolean contains(Object o) {    
433             return containsValue(o);    
434         }    
435         public void clear() {    
436             Hashtable.this.clear();    
437         }    
438     }    
439    
440     // 重新equals()函数    
441     // 若两个Hashtable的所有key-value键值对都相等,则判断它们两个相等    
442     public synchronized boolean equals(Object o) {    
443         if (o == this)    
444             return true;    
445    
446         if (!(o instanceof Map))    
447             return false;    
448         Map<K,V> t = (Map<K,V>) o;    
449         if (t.size() != size())    
450             return false;    
451    
452         try {    
453             // 通过迭代器依次取出当前Hashtable的key-value键值对    
454             // 并判断该键值对,存在于Hashtable中。    
455             // 若不存在,则立即返回false;否则,遍历完“当前Hashtable”并返回true。    
456             Iterator<Map.Entry<K,V>> i = entrySet().iterator();    
457             while (i.hasNext()) {    
458                 Map.Entry<K,V> e = i.next();    
459                 K key = e.getKey();    
460                 V value = e.getValue();    
461                 if (value == null) {    
462                     if (!(t.get(key)==null && t.containsKey(key)))    
463                         return false;    
464                 } else {    
465                     if (!value.equals(t.get(key)))    
466                         return false;    
467                 }    
468             }    
469         } catch (ClassCastException unused)   {    
470             return false;    
471         } catch (NullPointerException unused) {    
472             return false;    
473         }    
474    
475         return true;    
476     }    
477    
478     // 计算Entry的hashCode    
479     // 若 Hashtable的实际大小为0 或者 加载因子<0,则返回0。    
480     // 否则,返回“Hashtable中的每个Entry的key和value的异或值 的总和”。    
481     public synchronized int hashCode() {    
482         int h = 0;    
483         if (count == 0 || loadFactor < 0)    
484             return h;  // Returns zero    
485    
486         loadFactor = -loadFactor;  // Mark hashCode computation in progress    
487         Entry[] tab = table;    
488         for (int i = 0; i < tab.length; i++)    
489             for (Entry e = tab[i]; e != null; e = e.next)    
490                 h += e.key.hashCode() ^ e.value.hashCode();    
491         loadFactor = -loadFactor;  // Mark hashCode computation complete    
492    
493         return h;    
494     }    
495    
496     // java.io.Serializable的写入函数    
497     // 将Hashtable的“总的容量,实际容量,所有的Entry”都写入到输出流中    
498     private synchronized void writeObject(java.io.ObjectOutputStream s)    
499         throws IOException    
500     {    
501         // Write out the length, threshold, loadfactor    
502         s.defaultWriteObject();    
503    
504         // Write out length, count of elements and then the key/value objects    
505         s.writeInt(table.length);    
506         s.writeInt(count);    
507         for (int index = table.length-1; index >= 0; index--) {    
508             Entry entry = table[index];    
509    
510             while (entry != null) {    
511             s.writeObject(entry.key);    
512             s.writeObject(entry.value);    
513             entry = entry.next;    
514             }    
515         }    
516     }    
517    
518     // java.io.Serializable的读取函数:根据写入方式读出    
519     // 将Hashtable的“总的容量,实际容量,所有的Entry”依次读出    
520     private void readObject(java.io.ObjectInputStream s)    
521          throws IOException, ClassNotFoundException    
522     {    
523         // Read in the length, threshold, and loadfactor    
524         s.defaultReadObject();    
525    
526         // Read the original length of the array and number of elements    
527         int origlength = s.readInt();    
528         int elements = s.readInt();    
529    
530         // Compute new size with a bit of room 5% to grow but    
531         // no larger than the original size.  Make the length    
532         // odd if it's large enough, this helps distribute the entries.    
533         // Guard against the length ending up zero, that's not valid.    
534         int length = (int)(elements * loadFactor) + (elements / 20) + 3;    
535         if (length > elements && (length & 1) == 0)    
536             length--;    
537         if (origlength > 0 && length > origlength)    
538             length = origlength;    
539    
540         Entry[] table = new Entry[length];    
541         count = 0;    
542    
543         // Read the number of elements and then all the key/value objects    
544         for (; elements > 0; elements--) {    
545             K key = (K)s.readObject();    
546             V value = (V)s.readObject();    
547                 // synch could be eliminated for performance    
548                 reconstitutionPut(table, key, value);    
549         }    
550         this.table = table;    
551     }    
552    
553     private void reconstitutionPut(Entry[] tab, K key, V value)    
554         throws StreamCorruptedException    
555     {    
556         if (value == null) {    
557             throw new java.io.StreamCorruptedException();    
558         }    
559         // Makes sure the key is not already in the hashtable.    
560         // This should not happen in deserialized version.    
561         int hash = key.hashCode();    
562         int index = (hash & 0x7FFFFFFF) % tab.length;    
563         for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {    
564             if ((e.hash == hash) && e.key.equals(key)) {    
565                 throw new java.io.StreamCorruptedException();    
566             }    
567         }    
568         // Creates the new entry.    
569         Entry<K,V> e = tab[index];    
570         tab[index] = new Entry<K,V>(hash, key, value, e);    
571         count++;    
572     }    
573    
574     // Hashtable的Entry节点,它本质上是一个单向链表。    
575     // 也因此,我们才能推断出Hashtable是由拉链法实现的散列表    
576     private static class Entry<K,V> implements Map.Entry<K,V> {    
577         // 哈希值    
578         int hash;    
579         K key;    
580         V value;    
581         // 指向的下一个Entry,即链表的下一个节点    
582         Entry<K,V> next;    
583    
584         // 构造函数    
585         protected Entry(int hash, K key, V value, Entry<K,V> next) {    
586             this.hash = hash;    
587             this.key = key;    
588             this.value = value;    
589             this.next = next;    
590         }    
591    
592         protected Object clone() {    
593             return new Entry<K,V>(hash, key, value,    
594                   (next==null ? null : (Entry<K,V>) next.clone()));    
595         }    
596    
597         public K getKey() {    
598             return key;    
599         }    
600    
601         public V getValue() {    
602             return value;    
603         }    
604    
605         // 设置value。若value是null,则抛出异常。    
606         public V setValue(V value) {    
607             if (value == null)    
608                 throw new NullPointerException();    
609    
610             V oldValue = this.value;    
611             this.value = value;    
612             return oldValue;    
613         }    
614    
615         // 覆盖equals()方法,判断两个Entry是否相等。    
616         // 若两个Entry的key和value都相等,则认为它们相等。    
617         public boolean equals(Object o) {    
618             if (!(o instanceof Map.Entry))    
619                 return false;    
620             Map.Entry e = (Map.Entry)o;    
621    
622             return (key==null ? e.getKey()==null : key.equals(e.getKey())) &&    
623                (value==null ? e.getValue()==null : value.equals(e.getValue()));    
624         }    
625    
626         public int hashCode() {    
627             return hash ^ (value==null ? 0 : value.hashCode());    
628         }    
629    
630         public String toString() {    
631             return key.toString()+"="+value.toString();    
632         }    
633     }    
634    
635     private static final int KEYS = 0;    
636     private static final int VALUES = 1;    
637     private static final int ENTRIES = 2;    
638    
639     // Enumerator的作用是提供了“通过elements()遍历Hashtable的接口” 和 “通过entrySet()遍历Hashtable的接口”。    
640     private class Enumerator<T> implements Enumeration<T>, Iterator<T> {    
641         // 指向Hashtable的table    
642         Entry[] table = Hashtable.this.table;    
643         // Hashtable的总的大小    
644         int index = table.length;    
645         Entry<K,V> entry = null;    
646         Entry<K,V> lastReturned = null;    
647         int type;    
648    
649         // Enumerator是 “迭代器(Iterator)” 还是 “枚举类(Enumeration)”的标志    
650         // iterator为true,表示它是迭代器;否则,是枚举类。    
651         boolean iterator;    
652    
653         // 在将Enumerator当作迭代器使用时会用到,用来实现fail-fast机制。    
654         protected int expectedModCount = modCount;    
655    
656         Enumerator(int type, boolean iterator) {    
657             this.type = type;    
658             this.iterator = iterator;    
659         }    
660    
661         // 从遍历table的数组的末尾向前查找,直到找到不为null的Entry。    
662         public boolean hasMoreElements() {    
663             Entry<K,V> e = entry;    
664             int i = index;    
665             Entry[] t = table;    
666             /* Use locals for faster loop iteration */   
667             while (e == null && i > 0) {    
668                 e = t[--i];    
669             }    
670             entry = e;    
671             index = i;    
672             return e != null;    
673         }    
674    
675         // 获取下一个元素    
676         // 注意:从hasMoreElements() 和nextElement() 可以看出“Hashtable的elements()遍历方式”    
677         // 首先,从后向前的遍历table数组。table数组的每个节点都是一个单向链表(Entry)。    
678         // 然后,依次向后遍历单向链表Entry。    
679         public T nextElement() {    
680             Entry<K,V> et = entry;    
681             int i = index;    
682             Entry[] t = table;    
683             /* Use locals for faster loop iteration */   
684             while (et == null && i > 0) {    
685                 et = t[--i];    
686             }    
687             entry = et;    
688             index = i;    
689             if (et != null) {    
690                 Entry<K,V> e = lastReturned = entry;    
691                 entry = e.next;    
692                 return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e);    
693             }    
694             throw new NoSuchElementException("Hashtable Enumerator");    
695         }    
696    
697         // 迭代器Iterator的判断是否存在下一个元素    
698         // 实际上,它是调用的hasMoreElements()    
699         public boolean hasNext() {    
700             return hasMoreElements();    
701         }    
702    
703         // 迭代器获取下一个元素    
704         // 实际上,它是调用的nextElement()    
705         public T next() {    
706             if (modCount != expectedModCount)    
707                 throw new ConcurrentModificationException();    
708             return nextElement();    
709         }    
710    
711         // 迭代器的remove()接口。    
712         // 首先,它在table数组中找出要删除元素所在的Entry,    
713         // 然后,删除单向链表Entry中的元素。    
714         public void remove() {    
715             if (!iterator)    
716                 throw new UnsupportedOperationException();    
717             if (lastReturned == null)    
718                 throw new IllegalStateException("Hashtable Enumerator");    
719             if (modCount != expectedModCount)    
720                 throw new ConcurrentModificationException();    
721    
722             synchronized(Hashtable.this) {    
723                 Entry[] tab = Hashtable.this.table;    
724                 int index = (lastReturned.hash & 0x7FFFFFFF) % tab.length;    
725    
726                 for (Entry<K,V> e = tab[index], prev = null; e != null;    
727                      prev = e, e = e.next) {    
728                     if (e == lastReturned) {    
729                         modCount++;    
730                         expectedModCount++;    
731                         if (prev == null)    
732                             tab[index] = e.next;    
733                         else   
734                             prev.next = e.next;    
735                         count--;    
736                         lastReturned = null;    
737                         return;    
738                     }    
739                 }    
740                 throw new ConcurrentModificationException();    
741             }    
742         }    
743     }    
744    
745    
746     private static Enumeration emptyEnumerator = new EmptyEnumerator();    
747     private static Iterator emptyIterator = new EmptyIterator();    
748    
749     // 空枚举类    
750     // 当Hashtable的实际大小为0;此时,又要通过Enumeration遍历Hashtable时,返回的是“空枚举类”的对象。    
751     private static class EmptyEnumerator implements Enumeration<Object> {    
752    
753         EmptyEnumerator() {    
754         }    
755    
756         // 空枚举类的hasMoreElements() 始终返回false    
757         public boolean hasMoreElements() {    
758             return false;    
759         }    
760    
761         // 空枚举类的nextElement() 抛出异常    
762         public Object nextElement() {    
763             throw new NoSuchElementException("Hashtable Enumerator");    
764         }    
765     }    
766    
767    
768     // 空迭代器    
769     // 当Hashtable的实际大小为0;此时,又要通过迭代器遍历Hashtable时,返回的是“空迭代器”的对象。    
770     private static class EmptyIterator implements Iterator<Object> {    
771    
772         EmptyIterator() {    
773         }    
774    
775         public boolean hasNext() {    
776             return false;    
777         }    
778    
779         public Object next() {    
780             throw new NoSuchElementException("Hashtable Iterator");    
781         }    
782    
783         public void remove() {    
784             throw new IllegalStateException("Hashtable Iterator");    
785         }    
786    
787     }    
788 }   
View Code

几点总结

    针对Hashtable,我们同样给出几点比较重要的总结,但要结合与HashMap的比较来总结。

    1、二者的存储结构和解决冲突的方法都是相同的。

    2、HashTable在不指定容量的情况下的默认容量为11,而HashMap为16,Hashtable不要求底层数组的容量一定要为2的整数次幂,而HashMap则要求一定为2的整数次幂。

    3、Hashtable中key和value都不允许为null,而HashMap中key和value都允许为null(key只能有一个为null,而value则可以有多个为null)。但是如果在Hashtable中有类似put(null,null)的操作,编译同样可以通过,因为key和value都是Object类型,但运行时会抛出NullPointerException异常,这是JDK的规范规定的。我们来看下ContainsKey方法和ContainsValue的源码:

 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  }    
21   
22  public boolean containsValue(Object value) {    
23      return contains(value);    
24  }    
25   
26  // 判断Hashtable是否包含key    
27  public synchronized boolean containsKey(Object key) {    
28      Entry tab[] = table;    
29 /计算hash值,直接用key的hashCode代替  
30      int hash = key.hashCode();      
31      // 计算在数组中的索引值   
32      int index = (hash & 0x7FFFFFFF) % tab.length;    
33      // 找到“key对应的Entry(链表)”,然后在链表中找出“哈希值”和“键值”与key都相等的元素    
34      for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {    
35          if ((e.hash == hash) && e.key.equals(key)) {    
36              return true;    
37          }    
38      }    
39      return false;    
40  }    

    很明显,如果value为null,会直接抛出NullPointerException异常,但源码中并没有对key是否为null判断,有点小不解!不过NullPointerException属于RuntimeException异常,是可以由JVM自动抛出的,也许对key的值在JVM中有所限制吧。

    4、Hashtable扩容时,将容量变为原来的2倍加1,而HashMap扩容时,将容量变为原来的2倍。
    5、Hashtable计算hash值,直接用key的hashCode(),而HashMap重新计算了key的hash值,Hashtable在求hash值对应的位置索引时,用取模运算,而HashMap在求位置索引时,则用与运算,且这里一般先用hash&0x7FFFFFFF后,再对length取模,&0x7FFFFFFF的目的是为了将负的hash值转化为正值,因为hash值有可能为负数,而&0x7FFFFFFF后,只有符号外改变,而后面的位都不变。

posted @ 2018-04-10 16:56  kdy  阅读(166)  评论(0编辑  收藏  举报