HashMap vs Hashtable in Java
Both HashTable and HashMap implements Map interface but there are some differences between these two. They are:
- Thread Safety (synchronized)
- Null Keys
- Time Complexity
Thread Safety (synchronized)
First and most significant different between Hashtable and HashMap is that, HashMap is not thread-safe (unsynchronized) while Hashtable is a thread-safe (synchronized) collection. This makes HashMap better for non-threaded applications, as unsynchronized Objects typically perform better than synchronized ones.
Synchronized means only one thread can modify a hash table at one point of time. Basically, it means that any thread before performing an update on a hashtable will have to acquire a lock on the object while others will wait for lock to be released.
You can make the HashMap as thread-safe (synchronized) by calling this code
HashTable can only contain non-null object as a key or as a value. In order to store and retrieve objects from a hashtable, the objects used as keys must implement the hashCode method and the equals method. Since "null" isn't an object, you can't call .equals() or .hashCode() on it, so the Hashtable can't compute a hash to use it as a key.
HashMap can contain one null key and null values . It is newer, and has more advanced capabilities, which are basically just an improvement on the Hashtable functionality. When HashMap was created, it was specifically designed to handle null values as keys and handles them as a special case.
Though both HashMap and HashTable implement Map interface , but they extend two different classes. HashMap extends AbstractMap class where as HashTable extends Dictionary class which is the legacy class in JDK.
HashMap is not synchronized so it is fast. HashTable is internally synchronized , this makes HashTable slightly slower than the HashMap. Unsynchronized objects are often much better in performance in compare to synchronized object like Hashtable in single threaded environment.
HashMap is traversed by Iterator while Hashtable is traversed by Enumerator and Iterator.
Iterator in the HashMap is fail-safe while the enumerator for the Hashtable is not. Fail-safe is relevant from the context of iterators . If an iterator has been created on a collection object and some other thread tries to modify the collection object "structurally" , a concurrent modification exception will be thrown.
Hashtable uses Seperate chaining(with linked lists) as collision handling strategy bounding search time of O(n) . As of JAVA 8 HashMap uses Balanced Tree as collision resolution strategy which has bounding serach time of O(log n) .
HashMap is a member of Java Collection Framework right from the beginning of its introduction in JDK 1.2 . But, HashTable was there before JDK 1.2 and it extends Dictionary class which is the legacy class in JDK. From JDK 1.2, it has been made to implement Map interface , making it a member of collection framework.