{"id":4191,"date":"2019-05-10T13:07:56","date_gmt":"2019-05-10T17:07:56","guid":{"rendered":"http:\/\/springframework.guru\/?p=4191"},"modified":"2024-10-19T11:04:40","modified_gmt":"2024-10-19T15:04:40","slug":"java-hashmap-vs-hashtable","status":"publish","type":"post","link":"https:\/\/springframework.guru\/java-hashmap-vs-hashtable\/","title":{"rendered":"Java HashMap vs Hashtable"},"content":{"rendered":"\n
In Java, the HashMap and HashTable are both data structures that store data in key value pairs. When you store data in these, the key value is hashed, then is used as an index for fast access to the stored data.<\/p>\n\n\n\n
HashMap vs Hashtable<\/h2>\n\n\n\n
HashMap<\/strong><\/td>
Hashtable<\/strong><\/td><\/tr>
Introduced in Java 1.2<\/td>
Introduced in Java 1.0, considered obsolete with the addition of HashMap in Java 1.2<\/td><\/tr>
Not synchronized, not thread-safe<\/td>
Synchronized, thread-safe<\/td><\/tr>
Faster because it is not synchronized<\/td>
Slower due to synchronization overhead<\/td><\/tr>
Will allow one null key, and null values<\/td>
Will not allow null keys or null values<\/td><\/tr>
Extends AbstractMap<\/code> and implements Map<\/code> interface<\/td>
<\/td><\/tr><\/tbody><\/table>HashMap vs Hashtable<\/figcaption><\/figure>\n\n\n\n
Some other key differences are:<\/p>\n\n\n\n
\n
Because of synchronization and thread safety, Hashtable<\/code> is much slower than HashMap<\/code> if used in single threaded environment.<\/li>\n\n\n\n
HashMap<\/code> allows one null<\/code> key and multiple null<\/code> values whereas Hashtable<\/code> doesn’t allow null<\/code> values.<\/li>\n\n\n\n
HashMap<\/code> is traversed by Iterator<\/code> while Hashtable<\/code> can be traversed by both Iterator<\/code> and the legacy Enumeration<\/code>.<\/li>\n\n\n\n
Iterator<\/code> in HashMap<\/code> is a fail-fast iterator. It throws ConcurrentModificationException<\/code> if any thread other than the iterator\u2019s remove()<\/code> method tries to modify the map structurally. Thus, in the face of concurrent modification, the iterator fails fast and cleanly, rather than risking undesirable behaviour. However, The Enumeration<\/code> returned by Hashtable<\/code> doesn’t have this behaviour.<\/li>\n<\/ul>\n\n\n\n
In addition to these differences, one commonly asked question is Why HashMap<\/code> stores one null key but Hashtable<\/code> does not?<\/em><\/p>\n\n\n\n
HashMap<\/code>, allows storing one null<\/code> key and multiple null<\/code> values. The reason for allowing only one null<\/code> key is because keys in a HashMap<\/code> has to be unique. On the other hand Hashtable<\/code> does not allow null<\/code> keys. This is because the objects used as keys in a Hashtable<\/code> implements the hashCode()<\/code> and equals()<\/code> methods for their storage and retrieval. Since null<\/code> is not an object it cannot implement the methods. If you try hashing a null<\/code> key, it will throw a NullPointerException<\/code>.<\/p>\n\n\n\n
Synchronization with Hashtable<\/h2>\n\n\n\n
While Hashtable<\/code> does have built-in synchronization, it may not be enough to ensure complete thread safety. This is because the synchronization is applied at the method level. <\/p>\n\n\n\n
For example you might check if a key exists with containsKey()<\/code> before a put()<\/code> operation. Another thread could add the key between method calls, leading to an unexpected exception. <\/p>\n\n\n\n