Hashtable Vs Hashmap in Java [In-Depth Tutorial]

Hashtable and Hashmap are two commonly used data structures in Java that allow efficient storage and retrieval of key-value pairs. While they share similar functionalities, there are some notable differences between them that developers should be aware of when choosing between them for their Java applications. In this article, we will explore the differences between Hashtable and Hashmap in Java, including their performance, synchronization, and usage scenarios. By the end of this article, you will have a clear understanding of Hashtable Vs Hashmap and be able to make an informed decision on which one to use for your specific use case.

HashMap and Hashtable Overview

Now we will try to understand what are HashMap and Hashtable in java.

HashMap in Java

A HashMap is an implementation of the Map interface in Java. It allows you to store and retrieve key-value pairs in a way that is optimized for fast lookup of values based on their keys. HashMap uses a hash table data structure to store the key-value pairs, where each key is hashed and the corresponding value is stored in the hash table based on its hash code.

HashMap is not synchronized by default, which means that it is not thread-safe. This means that if multiple threads access a HashMap simultaneously, it can result in undefined behavior, including data corruption and inconsistent results. However, you can make a HashMap thread-safe by using the ConcurrentHashMap class, which is a thread-safe implementation of HashMap.

Another important feature of HashMap is that it allows null keys and values. This means that you can store null as a key or a value in a HashMap. However, it's important to note that using null keys or values can sometimes lead to unexpected behavior, so it's generally recommended to avoid using null values as much as possible.

Example of HashMap in Java

Now, let us take an example of HashMap in java to understand the concept fully.

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        // Create a new HashMap
        HashMap<String, Integer> myMap = new HashMap<>();

        // Add key-value pairs to the HashMap
        myMap.put("Alice", 25);
        myMap.put("Bob", 30);
        myMap.put("Charlie", 35);

        // Retrieve a value based on a key
        int aliceAge = myMap.get("Alice");
        System.out.println("Alice's age is " + aliceAge);

        // Update a value based on a key
        myMap.put("Alice", 26);
        aliceAge = myMap.get("Alice");
        System.out.println("Alice's new age is " + aliceAge);

        // Remove a key-value pair
        myMap.remove("Charlie");

        // Iterate over the key-value pairs
        for (String key : myMap.keySet()) {
            int value = myMap.get(key);
            System.out.println(key + " is " + value + " years old");
        }
    }
}

In this example, we create a new HashMap called myMap and add three key-value pairs to it using the put() method. We then retrieve Alice's age using the get() method, update her age using put(), and remove Charlie from the map using remove(). Finally, we iterate over the key-value pairs using a for-each loop and print out each key-value pair.

Hashtable in Java

Hashtable is another implementation of the Map interface in Java. It is similar to a HashMap, but it is synchronized, which means that it is thread-safe. This means that if multiple threads access a Hashtable simultaneously, it will not result in data corruption or inconsistent results. Hashtable also uses a hash table data structure to store the key-value pairs, similar to HashMap.

One key difference between Hashtable and HashMap is that Hashtable does not allow null keys or values. This means that if you try to store a null key or value in a Hashtable, it will throw a NullPointerException. Additionally, Hashtable uses an Enumeration object to iterate over the key-value pairs, while HashMap allows you to use an iterator or a for-each loop.

It's important to note that while Hashtable is thread-safe, this comes at a performance cost. Because Hashtable is synchronized, it has to acquire locks before performing any operation on it, which can slow down the performance of your program. For this reason, if you don't need the extra thread safety provided by Hashtable, it's generally recommended to use HashMap instead for better performance.

Example of Hashtable in Java

Here is an example of Hashtable in Java.

import java.util.Hashtable;

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

        // Add key-value pairs to the Hashtable
        myTable.put("Alice", 25);
        myTable.put("Bob", 30);
        myTable.put("Charlie", 35);

        // Retrieve a value based on a key
        int aliceAge = myTable.get("Alice");
        System.out.println("Alice's age is " + aliceAge);

        // Update a value based on a key
        myTable.put("Alice", 26);
        aliceAge = myTable.get("Alice");
        System.out.println("Alice's new age is " + aliceAge);

        // Remove a key-value pair
        myTable.remove("Charlie");

        // Iterate over the key-value pairs
        Enumeration<String> keys = myTable.keys();
        while (keys.hasMoreElements()) {
            String key = keys.nextElement();
            int value = myTable.get(key);
            System.out.println(key + " is " + value + " years old");
        }
    }
}

In this example, we create a new Hashtable called myTable and add three key-value pairs to it using the put() method. We then retrieve Alice's age using the get() method, update her age using put(), and remove Charlie from the table using remove(). Finally, we iterate over the key-value pairs using an Enumeration object and print out each key-value pair. Note that we need to use an Enumeration object to iterate over the key-value pairs in a Hashtable, unlike a HashMap where we can use a for-each loop or an iterator

HashMap Vs Hashtable Differences

Here are the key differences between a HashMap and a Hashtable:

Summary

In summary, Hashtable and Hashmap are two widely used data structures in Java for storing key-value pairs efficiently. Although they offer similar functionalities, they have some significant differences that developers should consider before choosing between them. Hashtable is synchronized and thread-safe, making it suitable for multi-threaded applications, while Hashmap is not synchronized and faster than Hashtable, making it a better choice for single-threaded applications. Additionally, Hashtable does not allow null keys or values, while Hashmap does. Understanding the differences between Hashtable Vs Hashmap in Java is crucial for optimizing the performance and efficiency of your Java application.

Further Reading

HashMap in java
Hashtable in Java