Hashtable vs ConcurrentHashMap

When handling key-value pairs in a Java application, two primary options come to mind: Hashtable and ConcurrentHashMap. Despite both providing thread safety, their underlying architectures and features vary. Whether developing a legacy system or modern cloud-based microservices, discerning these nuances is crucial for informed decision-making. Let us delve into a practical approach to understanding Java Hashtable vs ConcurrentHashMap.

1. Hashtable

In Java, a Hashtable is a data structure that implements the Map interface, which is part of the Java Collections Framework. It stores key-value pairs, where each key must be unique. It uses a hash table to store the key-value pairs and provides constant-time complexity for basic operations such as get and put.

Here’s a simple example of using Hashtable in Java:

package com.javacodegeeks;

import java.util.Hashtable;
import java.util.Map;

public class HashtableExample {
    public static void main(String[] args) {
        // Create a Hashtable
        Hashtable<String, Integer> hashtable = new Hashtable<>();

        // Add key-value pairs to the Hashtable
        hashtable.put("John", 25);
        hashtable.put("Alice", 30);
        hashtable.put("Bob", 22);

        // Access values using keys
        System.out.println("Age of John: " + hashtable.get("John"));
        System.out.println("Age of Alice: " + hashtable.get("Alice"));

        // Update a value
        hashtable.put("John", 26);
        System.out.println("Updated age of John: " + hashtable.get("John"));

        // Remove a key-value pair
        hashtable.remove("Bob");

        // Iterate over the key-value pairs
        System.out.println("Iterating over key-value pairs:");
        for (Map.Entry<String, Integer> entry : hashtable.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }

        // Check if a key is present
        System.out.println("Is Bob present? " + hashtable.containsKey("Bob"));
    }
}

In this example, a Hashtable is created using Hashtable<String, Integer>, where String represents the type of keys, and Integer represents the type of values. Key-value pairs are added using the put method and values are accessed using the get method.

The output of the provided code would be:

Age of John: 25
Age of Alice: 30
Updated age of John: 26
Iterating over key-value pairs:
Alice: 30
John: 26
Is Bob present? False

2. ConcurrentHashMap

ConcurrentHashMap is a class in Java that provides a concurrent, thread-safe implementation of the Map interface. It is part of the Java Collections Framework and is designed to be used in a multi-threaded environment. Unlike the traditional Hashtable, ConcurrentHashMap provides better concurrency and performance by dividing the map into segments, allowing multiple threads to operate on different segments simultaneously.

Here’s an example of using ConcurrentHashMap in Java:

package com.javacodegeeks;

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExample {
    public static void main(String[] args) {
        // Create a ConcurrentHashMap
        ConcurrentHashMap<String, Integer> concurrentHashMap = new ConcurrentHashMap<>();

        // Add key-value pairs to the ConcurrentHashMap
        concurrentHashMap.put("John", 25);
        concurrentHashMap.put("Alice", 30);
        concurrentHashMap.put("Bob", 22);

        // Access values using keys
        System.out.println("Age of John: " + concurrentHashMap.get("John"));
        System.out.println("Age of Alice: " + concurrentHashMap.get("Alice"));

        // Update a value
        concurrentHashMap.put("John", 26);
        System.out.println("Updated age of John: " + concurrentHashMap.get("John"));

        // Remove a key-value pair
        concurrentHashMap.remove("Bob");

        // Iterate over the key-value pairs
        System.out.println("Iterating over key-value pairs:");
        concurrentHashMap.forEach((key, value) -> System.out.println(key + ": " + value));

        // Check if a key is present
        System.out.println("Is Bob present? " + concurrentHashMap.containsKey("Bob"));
    }
}

In this example, a ConcurrentHashMap is created using ConcurrentHashMap<String, Integer>. Key-value pairs are added, updated, and removed using methods similar to those of other Map implementations. The forEach method is used to iterate over the key-value pairs, and the containsKey method is used to check if a key is present.

The output of the provided code would be:

Age of John: 25
Age of Alice: 30
Updated age of John: 26
Iterating over key-value pairs:
Alice: 30
John: 26
Is Bob present? False

3. Differences between Hashtable and ConcurrentHashMap

Here’s a comparison between Hashtable and ConcurrentHashMap:

4. Conclusion

In conclusion, the choice between Hashtable and ConcurrentHashMap in Java depends on the specific requirements and characteristics of the application. While Hashtable is a legacy class suitable for scenarios with minimal concurrency or in a single-threaded environment, it may experience contention and reduced performance under heavy concurrent access due to its single-lock mechanism. On the other hand, ConcurrentHashMap, introduced in Java 5 as part of the java.util.concurrent package is designed to provide better scalability and performance in high-concurrency scenarios. It achieves this by employing a fine-grained approach with segment-level locks, allowing multiple threads to operate on different segments concurrently. Additionally, ConcurrentHashMap offers fail-safe iterator methods, preventing ConcurrentModificationExceptions during iteration when the map is structurally modified. In summary, developers should consider the concurrency requirements of their applications and choose the appropriate class accordingly, with Hashtable for simpler scenarios and ConcurrentHashMap for improved concurrency support and performance in multi-threaded environments.

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

and many more ....

I agree to the Terms and Privacy Policy

Sign up

Thank you!

We will contact you soon.