Difference Between HashMap and Hashtable

HashMap and Hashtable both store key-value pairs in a hash table and both implement the Map interface. The main differences are that Hashtable is synchronized and rejects null, while HashMap is not synchronized and accepts null. In this lesson, you will learn all the differences, see them in code, and learn which map to use for shared data.

Example: The null Difference

Let's see an example that stores null in both maps.

import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
 
public class NullTest {
    static void test(Map<String, String> map) {
        String name = map.getClass().getSimpleName();
        try {
            map.put(null, "no key");
            map.put("Navika", null);
            System.out.println(name + ": accepted, " + map);
        } catch (NullPointerException e) {
            System.out.println(name + ": NullPointerException");
        }
    }
 
    public static void main(String[] args) {
        test(new HashMap<>());
        test(new Hashtable<>());
    }
}

HashMap: accepted, {null=no key, Navika=null}
Hashtable: NullPointerException

Explanation: The same method is called with both maps. HashMap stores a null key and a null value. Hashtable throws as soon as it meets the null key.

Differences Between HashMap and Hashtable

What to Use for Shared Maps

Hashtable locks the whole map for every call. ConcurrentHashMap was designed for threads: reads don't block, and writes lock only a small part of the map. It also provides atomic compound operations such as merge and computeIfAbsent.

Common Mistakes

Assuming Hashtable makes "check, then put" safe. Two separate calls can still interleave; use putIfAbsent or merge.

Moving code from HashMap to ConcurrentHashMap without checking for null. ConcurrentHashMap rejects null too.

Interview Corner

Practice

1. Easy: Replace the Hashtable in the example with a ConcurrentHashMap and predict the output before running it.
2. Harder: Use two threads to add 10,000 keys each to a shared HashMap and to a shared ConcurrentHashMap. Compare the final sizes.

Key Takeaways