HashMap Hashtable Difference

Http://blog.csdn.net/java2000_net/archive/2008/06/05/2512510.aspx

Let's first look at the definition of 2 classes.

[Java]View Plain Copy

1. public class Hashtable
2. Extends Dictionary
3. Implements Map, Cloneable, java.io.Serializable

[Java]View Plain Copy

1. public class HashMap
2. Extends Abstractmap
3. Implements Map, Cloneable, Serializable

Visible hashtable inherit from Dictiionary and HashMap inherit from Abstractmap

The Put method of Hashtable is as follows

[Java]View Plain Copy

2. Public synchronized v put (K key, V value) {//###### Note here 1
4. Make sure the value was not null
6. if (value = = null) {//###### NOTE here 2
8. throw new NullPointerException ();
10. }
12. Makes sure the key is not already in the Hashtable.
14. Entry tab[] = table;
16. int hash = Key.hashcode (); ###### Note here 3
18. int index = (hash & 0x7FFFFFFF)% Tab.length;
20. for (Entry e = Tab[index]; E! = null; e = e.next) {
22. if ((E.hash = = hash) && e.key.equals (key)) {
24. V old = E.value;
26. E.value = value;
28. return old;
30. }
32. }
34. modcount++;
36. if (count >= threshold) {
38. Rehash the table if the threshold is exceeded
40. Rehash ();
42. tab = table;
44. Index = (hash & 0x7FFFFFFF)% Tab.length;
46. }
48. Creates the new entry.
50. Entry e = Tab[index];
52. Tab[index] = new Entry (hash, key, value, E);
54. count++;
56. return null;
58. }

Note The 1 method is synchronous
Note the 2 method does not allow Value==null
Note that the 3 method calls the Hashcode method of key, and if key==null, throws a null pointer exception HashMap The Put method is as follows

[Java]View Plain Copy

2. Public V put (K key, V value) {//###### Note here 1
4. if (key = = null)//###### Note here 2
6. return Putfornullkey (value);
8. int hash = hash (Key.hashcode ());
10. int i = indexfor (hash, table.length);
12. for (Entry e = table[i]; E! = null; e = e.next) {
14. Object K;
16. if (E.hash = = Hash && (k = e.key) = = Key | | key.equals (k)) {
18. V oldValue = E.value;
20. E.value = value;
22. E.recordaccess (this);
24. return oldValue;
26. }
28. }
30. modcount++;
32. AddEntry (hash, key, value, I); ######, watch this.
34. return null;
36. }

Note The 1 method is non-synchronous
Note The 2 method allows key==null
Note the 3 method does not make any calls to value, so allow null

Add:
Hashtable has a contains method, easy to cause misunderstanding, so in hashmap inside has been removed
Of course, all 2 classes use the ContainsKey and Containsvalue methods.

HashMap Hashtable

Parent class Abstractmap Dictiionary

Whether to synchronize No is

K,v can null whether

HashMap is a lightweight implementation of Hashtable (non-thread-safe implementation), they all complete the map interface,

The main difference is that HASHMAP allows null (NULL) key values (key), which may be more efficient than Hashtable due to non-thread safety.

HashMap allows NULL to be used as a entry key or value, and Hashtable is not allowed.

HashMap hashtable contains method removed, changed to Containsvalue and ContainsKey. Because the contains method is easy to cause misunderstanding.

Hashtable inherits from the dictionary class, and HashMap is an implementation of the map interface introduced by Java1.2.

The biggest difference is that the Hashtable method is synchronize, and HashMap is not, when multiple threads access Hashtable, they do not need to synchronize their methods, and HashMap must provide it with external synchronization ( COLLECTIONS.SYNCHRONIZEDMAP).

The Hash/rehash algorithms used by Hashtable and HashMap are probably the same, so there is no big difference in performance.

HashMap Hashtable Difference