HashMap vs Hashtable

In this article “HashMap vs Hashtable”, we will explore the differences between HashMap and Hashtable, along with code examples and scenarios where each is more suitable.

HashMap vs hashtable

What is HashMap?

HashMap is a part of the Java Collections Framework and is used to store elements in key-value pairs. HashMap allows null values for both keys and values and is not synchronized, making it more efficient in single-threaded scenarios.

What is Hashtable?

Hashtable, like HashMap, is used to store key-value pairs, but it is a legacy class and not part of the Java Collections Framework. It is synchronized, making it thread-safe for use in multi-threaded environments. Unlike HashMap, Hashtable does not allow null values for keys or values.

HashMap vs Hashtable: Key Differences

Here are the key differences between HashMap and Hashtable:

IntroductionIntroduced in JDK 1.2Legacy class introduced in JDK 1.0
SynchronizationNot synchronized – Not thread-safeSynchronized – Thread-safe for multi-threaded use
Null Keys/ValuesNull keys/values are allowedNull keys/values are not allowed
PerformanceFaster due to no synchronizationSlower due to synchronization
IteratorIterator used for iterationEnumeration used for iteration
InheritanceExtends AbstractMap classExtends Dictionary class
Iterating OrderIterator may not guarantee insertion orderEnumeration does not guarantee any order

Java Code Example: HashMap vs Hashtable

Let’s see a code example to illustrate the differences between HashMap and Hashtable:

import java.util.*;

public class HashTableVsHashMapExample {
    public static void main(String[] args) {
        // Hashtable example
        Hashtable<Integer, String> ht = new Hashtable<>();
        ht.put(1, "One");
        ht.put(2, "Two");
        ht.put(3, "Three");

        // HashMap example
        HashMap<Integer, String> hm = new HashMap<>();
        hm.put(1, "One");
        hm.put(2, "Two");
        hm.put(3, "Three");

        // Iterating through Hashtable
        Enumeration<Integer> htKeys = ht.keys();
        while (htKeys.hasMoreElements()) {
            Integer key = htKeys.nextElement();
            System.out.println("Key: " + key + ", Value: " + ht.get(key));

        // Iterating through HashMap
        for (Map.Entry<Integer, String> entry : hm.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());


Key: 3, Value: Three
Key: 2, Value: Two
Key: 1, Value: One

Key: 1, Value: One
Key: 2, Value: Two
Key: 3, Value: Three

When to Use HashMap and When to Use Hashtable

  • Use HashMap when you need a faster and more efficient data structure for single-threaded scenarios and are sure about no concurrent modifications.
  • Use Hashtable when you require thread-safe operations and synchronization for multi-threaded environments.
  • If you need the ability to store null values for keys or values, use HashMap, as Hashtable does not allow nulls.

Conclusion: HashMap vs Hashtable

In this article “HashMap vs Hashtable”, we looked into key differences between a HashMap and a Hashtable. We then implemented a Java class to show the differences between HashMap and Hashtable.

In summary, both Hashtable and HashMap are used to store key-value pairs in Java, but they have significant differences in their implementation and behavior. Hashtable is a legacy class that provides synchronization, making it thread-safe, while HashMap does not provide synchronization for better performance in single-threaded scenarios.

Consider your specific requirements and the environment in which the data structure will be used to decide between Hashtable and HashMap in your Java applications.

Leave a Reply

Your email address will not be published. Required fields are marked *