What are the differences between a Java HashMap and a Hashtable?

In Java, both HashMap and Hashtable store data in key–value pairs using hashing, but they differ in several important ways.

1. Synchronization:
Hashtable is synchronized, meaning it is thread-safe only one thread can access it at a time.
HashMap, on the other hand, is not synchronized by default, so it’s faster but not thread-safe. If you need synchronization, you can wrap a HashMap using

Map map = Collections.synchronizedMap(new HashMap<>());

or use a ConcurrentHashMap instead.

2. Performance:
Because HashMap does not have the synchronization overhead, it performs faster than Hashtable in single-threaded applications.
Hashtable is slower due to its synchronized methods.

3. Null keys and values:
HashMap allows one null key and multiple null values.
Hashtable does not allow null keys or values, attempting to insert one will throw a NullPointerException.

4. Legacy status:
Hashtable is a legacy class from Java 1.0. It was later retrofitted to implement the Map interface, but it’s largely obsolete now.
HashMap was introduced in Java 1.2 as part of the modern Collections Framework.

5. Iteration:
HashMap uses an Iterator, which is fail-fast  it throws a ConcurrentModificationException if the map is modified while iterating.
Hashtable uses an Enumeration, which is not fail-fast.

Which is more efficient?
HashMap is generally more efficient because it’s unsynchronized and designed for modern applications.
If you need thread safety in a concurrent environment, prefer ConcurrentHashMap, not Hashtable.

The main difference between a HashMap and a Hashtable in Java lies in synchronization, performance and their ability to handle null values.

A HashMap is part of the modern Collections Framework (introduced in Java 1.2). It is not synchronized, which means it is faster but not thread-safe by default. It allows one null key and multiple null values, making it flexible and ideal for most single-threaded applications.

A Hashtable, on the other hand, is an older, legacy class that was introduced in Java 1.0. All of its methods are synchronized, which makes it thread-safe but also slower because synchronization introduces additional overhead. It also does not allow null keys or values  trying to insert any will cause a NullPointerException.

In terms of iteration, HashMap uses an Iterator that is fail-fast, meaning it throws an exception if the map is modified during iteration. Hashtable uses an Enumeration, which is not fail-fast and therefore doesn’t detect concurrent modifications.

When it comes to efficiency, HashMap is generally more efficient due to the lack of synchronization overhead. For concurrent applications, instead of using the old Hashtable, it’s better to use ConcurrentHashMap, which provides thread safety with better performance and scalability.

Both HashMap and Hashtable are used to store key–value pairs in Java, but there are some important differences between them.

A HashMap is a newer, non-synchronized implementation introduced in Java 1.2 as part of the Collections Framework. It allows one null key and multiple null values and because it’s not synchronized, it is generally faster in single-threaded environments. HashMap uses an Iterator to traverse elements and it is fail-fast, meaning it throws an exception if the map is modified while being iterated.

A Hashtable, in contrast, is an older class that dates back to Java 1.0. It is synchronized, which means all of its methods are thread-safe, but this also makes it slower compared to HashMap. It does not allow null keys or values and it uses an Enumeration for iteration, which is not fail-fast.

In practice, Hashtable is considered obsolete and rarely used in modern Java applications. If you need a thread-safe map, it’s better to use ConcurrentHashMap, which is more efficient and designed for concurrent access.

In short:

• Use HashMap for better performance in single-threaded code.
• Use ConcurrentHashMap for thread-safe operations.
• Avoid Hashtable, as it’s old and less efficient.