Difference between Hashmap and Hashtable

Last Updated on April 12, 2023 by Prepbytes

In Java, HashMap and Hashtable are two commonly used data structures for storing and retrieving key-value pairs. Both data structures implement the Map interface and provide similar functionality, but there are some important differences between them. In this article, we will explore the difference between HashMap and Hashtable and their implementations in detail.

HashMap in Java

HashMap is java.util package class that implements the Map interface. It stores key-value pairs in a hash table, which allows for fast retrieval and insertion of elements. A HashMap does not guarantee the order of its elements and allows null values for both keys and values.

The initial capacity of a HashMap is 16, and its load factor is 0.75 by default. If the number of entries exceeds the product of the load factor and current capacity, the current capacity is increased and all entries are rehashed for uniform distribution.

To learn more, refer to the articles:

• HashMap in Java
• Internal Working of HashMap in Java

Hashtable in Java

Hashtable is also java.util package class that implements the Map interface. It stores key-value pairs in a hash table, which allows for fast retrieval and insertion of elements. A Hashtable does not guarantee the order of its elements and does not allow null values for keys or values.

The initial capacity of a Hashtable is 11, and its load factor is 0.75 by default. When the number of entries exceeds the product of the load factor and current capacity, capacity is increased and entries are rehashed to ensure uniform distribution.

Difference between HashMap and Hashtable

Let us now discuss the difference between HashMap and Hashtable.

• Thread Safety
  Hashtable is thread-safe, which means that multiple threads can access it simultaneously without any issues. On the other hand, HashMap is not thread-safe and can cause problems if accessed by multiple threads at the same time.

• Null Values
  Hashtable does not allow null values for keys or values, whereas HashMap allows null values for both keys and values.

• Performance
  HashMap is generally faster than Hashtable because it is not synchronized. However, if thread safety is required, Hashtable can still be faster than a synchronized HashMap.

• Iteration Order
  HashMap does not guarantee the order of its elements, whereas Hashtable iterates through its elements in the order they were inserted.

• Initial Capacity
  HashMap has an initial capacity of 16, whereas Hashtable has an initial capacity of 11.

• Load Factor
  HashMap has a default load factor of 0.75, whereas Hashtable also has a default load factor of 0.75.

• Enumeration
  Hashtable uses an Enumeration to iterate through its elements, whereas HashMap uses an Iterator.

Examples to Demonstrate the Difference between HashMap and Hashtable

Let us see some Java code to show the difference between HashMap and Hashtable.

Example 1 of the Difference between HashMap and Hashtable
This Java Code shows how null values are handled by HashMap and Hashtable.

Code:

import java.util.HashMap;
import java.util.Hashtable;

class Main {

    public static void main(String[] args) {
        HashMap<String, String> hashMap = new HashMap<>();
        Hashtable<String, String> hashTable = new Hashtable<>();

        hashMap.put("key", null);
        //hashTable.put(null, "value"); // throws NullPointerException

        System.out.println("HashMap: " + hashMap.get("key"));
        System.out.println("Hashtable: " + hashTable.get("key"));
    }
}

Output:

HashMap: null
Hashtable: null

Explanation:
In this example, we add a null value to both HashMap and Hashtable and then try to retrieve it using the get() method. We can observe that HashMap allows null values, while Hashtable does not. If we try to add a null key or value to Hashtable, it will throw a NullPointerException. In the output, we get “HashMap: null” which means that the value of the key is null. In the next line, we get “Hashtable: null” which means that there is no such element present in the hashtable with the name “key”.

Example 2 of the Difference between HashMap and Hashtable
The following code will demonstrate the difference between HashMap and Hashtable regarding the insertion order.

Code:

import java.util.*;

class PrepBytes{

    public static void main(String[] args) {
        HashMap<String, String> hashMap = new HashMap<>();
        Hashtable<String, String> hashTable = new Hashtable<>();

        hashMap.put("Arnav", "value1");
        hashMap.put("key", "value2");
        hashMap.put("key3", "value3");

        hashTable.put("Arnav", "value1");
        hashTable.put("key", "value2");
        hashTable.put("keys", "value3");

        System.out.println("HashMap entries:");
        for (Map.Entry<String, String> entry : hashMap.entrySet()) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }

        System.out.println("Hashtable entries:");
        for (Map.Entry<String, String> entry : hashTable.entrySet()) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
    }
}

Output:

HashMap entries:
key3 : value3
Arnav : value1
key : value2
Hashtable entries:
Arnav : value1
key : value2
keys : value3

Explanation:
In this example, we create a HashMap and a Hashtable and add some key-value pairs to them. Then, we iterate over the entries of both data structures using a for-each loop and print the keys and values.

The output shows that the order of entries is not maintained in HashMap, whereas it is maintained in Hashtable. This is because Hashtable is synchronized and uses a locking mechanism to ensure that the entries are added and retrieved in the same order.

When to use HashMap and Hashtable

Since Hashtable and HashMap have some significant differences, it’s important to choose the right one for your application. Here are some suggestions on when to use HashMap and Hashtable.

Use Hashtable when:

• You need a thread-safe map
• You do not need to allow null keys or values
• You don’t need to worry about performance

Use HashMap when:

• You do not need a thread-safe map
• You need to allow null keys or values
• You need better performance than Hashtable

Conclusion
In summary, Hashtable and HashMap are two commonly used map implementations in Java. While they share many similarities, they have some important differences that should be considered when choosing one for your application. Hashtable is thread-safe and does not allow null keys or values, but can be slower than HashMap. HashMap is not thread-safe, but allows null keys and values and can be faster than Hashtable. By understanding the differences between these two maps, you can choose the right one for your application and ensure that your code runs smoothly and efficiently.

Frequently Asked Questions(FAQs)

Here are some Frequently Asked Questions on the “Difference between Hashmap and Hashtable”.

Ques 1. Can you add null values to a Hashtable or a HashMap in Java?
Ans. You can add null values to a HashMap, but not to a Hashtable.

Ques 2. How does Java handle collisions in hash tables?
Ans. In Java, collisions in hash tables are handled by using a technique called chaining. If two keys hash to the same index in the array, their values are stored in a linked list at that index.

Ques 3. What is the time complexity of hash table operations in Java?
Ans. The time complexity of hash table operations in Java is typically O(1), but can be O(n) in the worst case if there are many collisions.

Ques 4. How do you iterate over the entries in a hash table in Java?
Ans. To iterate over the entries in a hash table in Java, you can use the entrySet() method to get a set of key-value pairs, and then use a for-each loop to iterate over the set.

Ques 5. Can you create a custom hash function in Java?
Ans. Yes, you can create a custom hash function in Java by implementing the hashCode() method on your key object. This method should return an int that represents a hash value for the key.