【Java集合源码剖析】Hashtable源码剖析

Hashtable简介

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

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

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

HashTable源码剖析

Hashtable的源码的很多实现都与HashMap差不多，源码如下（加入了比较详细的注释）：

[java] view
plaincopy

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

几点总结

针对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的源码：

[java] view
plaincopy

  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. // 从后向前遍历table数组中的元素(Entry)
  9. // 对于每个Entry(单向链表)，逐个遍历，判断节点的值是否等于value
  10. Entry tab[] = table;
  11. for (int i = tab.length ; i-- > 0 ;) {
  12. for (Entry<K,V> e = tab[i] ; e != null ; e = e.next) {
  13. if (e.value.equals(value)) {
  14. return true;
  15. }
  16. }
  17. }
  18. return false;
  19. }
  20. public boolean containsValue(Object value) {
  21. return contains(value);
  22. }
  23. // 判断Hashtable是否包含key
  24. public synchronized boolean containsKey(Object key) {
  25. Entry tab[] = table;
  26. /计算hash值，直接用key的hashCode代替
  27. int hash = key.hashCode();
  28. // 计算在数组中的索引值
  29. int index = (hash & 0x7FFFFFFF) % tab.length;
  30. // 找到“key对应的Entry(链表)”，然后在链表中找出“哈希值”和“键值”与key都相等的元素
  31. for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
  32. if ((e.hash == hash) && e.key.equals(key)) {
  33. return true;
  34. }
  35. }
  36. return false;
  37. }

很明显，如果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后，只有符号外改变，而后面的位都不变。

时间： 2024-10-25 02:33:08

【Java集合源码剖析】Hashtable源码剖析的相关文章

【转】Java 集合系列11之 Hashtable详细介绍(源码解析)和使用示例

概要 前一章,我们学习了HashMap.这一章,我们对Hashtable进行学习.我们先对Hashtable有个整体认识,然后再学习它的源码,最后再通过实例来学会使用Hashtable.第1部分 Hashtable介绍第2部分 Hashtable数据结构第3部分 Hashtable源码解析(基于JDK1.6.0_45)第4部分 Hashtable遍历方式第5部分 Hashtable示例 转载请注明出处:http://www.cnblogs.com/skywang12345/p/3310887.h

【源码】Hashtable源码剖析

注:以下源码基于jdk1.7.0_11 上一篇分析了HashMap的源码,相信大家对HashMap都有了更深入的理解.本文将介绍Map集合的另一个常用类,Hashtable. Hashtable出来的比HashMap早,HashMap 1.2才有,而Hashtable在1.0就已经出现了.HashMap和Hashtable实现原理基本一样,都是通过哈希表实现.而且两者处理冲突的方式也一样,都是通过链表法.下面我们就详细介绍下这个类. 首先看类声明: public class Hashtable<

Java 集合系列11之 Hashtable详细介绍(源码解析)和使用示例

概要 前一章,我们学习了HashMap.这一章,我们对Hashtable进行学习.我们先对Hashtable有个整体认识,然后再学习它的源码,最后再通过实例来学会使用Hashtable.第1部分 Hashtable介绍第2部分 Hashtable数据结构第3部分 Hashtable源码解析(基于JDK1.6.0_45)第4部分 Hashtable遍历方式第5部分 Hashtable示例 转载:http://www.cnblogs.com/skywang12345/p/3310887.html 第

1.Java集合-HashMap实现原理及源码分析

哈希表(Hash  Table)也叫散列表,是一种非常重要的数据结构,应用场景及其丰富,许多缓存技术(比如memcached)的核心其实就是在内存中维护一张大的哈希表,而HashMap的实现原理也常常出现在各类的面试题中,这里对java集合框架中的对应实现HashMap的实现原理进行讲解,然后对JDK7的HashMap的源码进行分析 哈希算法,是一类算法: 哈希表(Hash  Table)是一种数据结构: 哈希函数:是支撑哈希表的一类函数: HashMap 是 Java中用哈希数据结构实现的Ma

深入Java集合学习系列：Hashtable的实现原理

第1部分 Hashtable介绍 和HashMap一样,Hashtable 也是一个散列表,它存储的内容是键值对(key-value)映射.Hashtable 继承于Dictionary,实现了Map.Cloneable.java.io.Serializable接口.Hashtabl 的函数都是同步的,这意味着它是线程安全的.它的key.value都不可以为null.此外,Hashtable中的映射不是有序的.Hashtable 的实例有两个参数影响其性能:初始容量 和 加载因子. 容量 是哈希

6.Java集合-LinkedList实现原理及源码分析

Java中LinkedList的部分源码(本文针对1.7的源码) LinkedList的基本结构 jdk1.7之后,node节点取代了 entry ,带来的变化是,将1.6中的环形结构优化为了直线型链表结构,从双向循环链表变成了双向链表 在LinkedList中,我们把链子的"环"叫做"节点",每个节点都是同样的结构.节点与节点之间相连,构成了我们LinkedList的基本数据结构,也是LinkedList的核心. 我们再来看一下LinkedList在jdk1.6和

【Java集合】试读LinkedList源码

LinkedList的本质是双向链表.(01) LinkedList继承于AbstractSequentialList,并且实现了Dequeue接口. (02) LinkedList包含两个重要的成员:header 和 size. header是双向链表的表头,它是双向链表节点所对应的类Entry的实例.Entry中包含成员变量: previous, next, element.其中,previous是该节点的上一个节点,next是该节点的下一个节点,element是该节点所包含的值.  siz

Java集合框架之一：ArrayList源码分析

版权声明:本文为博主原创文章,转载请注明出处,欢迎交流学习! ArrayList底层维护的是一个动态数组,每个ArrayList实例都有一个容量.该容量是指用来存储列表元素的数组的大小.它总是至少等于列表的大小.随着向 ArrayList 中不断添加元素,其容量也自动增长. ArrayList不是同步的(也就是说不是线程安全的),如果多个线程同时访问一个ArrayList实例,而其中至少一个线程从结构上修改了列表,那么它必须保持外部同步,在多线程环境下,可以使用Collections.synch

2.Java集合-ConcurrentHashMap实现原理及源码分析

一.为何用ConcurrentHashMap 在并发编程中使用HashMap可能会导致死循环,而使用线程安全的HashTable效率又低下. 线程不安全的HashMap 在多线程环境下,使用HashMap进行put操作会引起死循环,导致CPU利用率接近100%,所以在并发情况下不能使用HashMap 效率低下的HashTable Hashtable使用synchronized来保证线程的安全,但是在线程竞争激烈的情况下Hashtable的效率非常低下.当一个线程访问Hashtable的同步方法,

深入理解JAVA集合系列四：ArrayList源码解读

在开始本章内容之前,这里先简单介绍下List的相关内容. List的简单介绍 有序的collection,用户可以对列表中每个元素的插入位置进行精确的控制.用户可以根据元素的整数索引(在列表中的位置)访问元素,并搜索列表中的元素.列表通常允许重复的元素,且允许null元素的存放. ArrayList的简单介绍 JDK中这样定义ArrayList:List接口的大小可变数据的实现. 主要有以下特点: 1.有序 2.线程不安全 3.元素可以重复 4.可以存放null值 顾名思义,取名ArrayLis