Difference between HashMap vs. HashSet and HashMap vs. Concurrent HashMap in Java?

Tweet

In Java, HashMap, HashSet, and Concurrent HashMap are essential components of the Java Collections Framework, each serving distinct purposes when it comes to storing and managing data. In this blog post, we will explore the differences between HashMap vs. HashSet and HashMap vs. Concurrent HashMap, complete with examples to clarify their use cases.

HashMap vs. HashSet

HashMap

HashMap is a data structure used to store key-value pairs. It uses a hashing mechanism to quickly retrieve values based on their keys. Here are some key characteristics of HashMap:

• Allows duplicate values but not duplicate keys.
• Provides efficient key-value retrieval using hashing.
• Does not maintain order (the order of elements is not guaranteed).
• Accepts null values and a single null key.

HashSet

HashSet, on the other hand, is used to store a collection of unique values. It does not allow duplicate elements. Here are some key characteristics of HashSet:

• Stores only unique values (no duplicate elements).
• Does not guarantee any specific order for elements.
• Does not allow null values.

Preventing Duplicate Values in HashSet

The primary reason HashSet does not allow duplicate elements is due to its underlying data structure: it is backed by a HashMap. When you add elements to a HashSet, they are stored as keys in the underlying HashMap, with the corresponding values being a constant, which is typically null.

public class HashSet<E> extends HashMap<E, Object> implements Set<E> {
    // ...
}

This design means that duplicate elements are naturally prevented because keys in a HashMap must be unique.

Example: HashMap vs. HashSet

Let's illustrate the difference between HashMap and HashSet with an example:

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class HashMapVsHashSetExample {
    public static void main(String[] args) {
        // HashMap example
        Map<String, Integer> hashMap = new HashMap<>();
        hashMap.put("Alice", 25);
        hashMap.put("Bob", 30);
        hashMap.put("Alice", 28); // Updates the value for "Alice"
        
        // HashSet example
        Set<String> hashSet = new HashSet<>();
        hashSet.add("Alice");
        hashSet.add("Bob");
        hashSet.add("Alice"); // Ignored, as "Alice" is already in the set
        
        System.out.println("HashMap: " + hashMap);
        System.out.println("HashSet: " + hashSet);
    }
}

In this example, the HashMap stores key-value pairs, and you can see that it allows duplicate keys, updating the value for "Alice." In contrast, the HashSet stores only unique values, so the duplicate "Alice" entry is ignored.

HashMap vs. ConcurrentHashMap: Handling Concurrent Modification

In the context of concurrent access and modification, an important consideration is how these data structures handle concurrent operations without causing issues like the ConcurrentModificationException. Let's delve into this aspect:

HashMap

HashMap, being non-thread-safe, is susceptible to the ConcurrentModificationException when multiple threads attempt to modify it simultaneously. This exception occurs when one thread is iterating over the elements of the HashMap while another thread adds, removes, or modifies elements. The result can be unpredictable and may lead to data corruption or unexpected behavior.

HashMap<String, Integer> hashMap = new HashMap<>();
// ...
// Concurrent modification example
Iterator<String> iterator = hashMap.keySet().iterator();
while (iterator.hasNext()) {
    String key = iterator.next();
    if (someCondition) {
        hashMap.remove(key); // ConcurrentModificationException may occur
    }
}

In this example, if another thread modifies the hashMap while this iteration is in progress, it can throw a ConcurrentModificationException.

ConcurrentHashMap

ConcurrentHashMap is specifically designed to handle concurrent modifications safely. It employs a combination of techniques like lock striping and fine-grained locking to ensure that multiple threads can read and modify the map concurrently without causing ConcurrentModificationException or data corruption.

ConcurrentHashMap<String, Integer> concurrentHashMap = new ConcurrentHashMap<>();
// ...
// Concurrent modification is safe
concurrentHashMap.compute("Key", (key, value) -> {
    if (value == null) {
        return 1;
    } else {
        return value + 1;
    }
});

In this example, multiple threads can safely update the concurrentHashMap concurrently without encountering issues.

By using ConcurrentHashMap in concurrent scenarios, you can avoid ConcurrentModificationException and ensure that your code behaves predictably even with multiple threads accessing and modifying the map simultaneously.

Conclusion

In summary:

• Use HashMap when you need to store key-value pairs with efficient key-based retrieval.
• Use HashSet when you need to store a collection of unique values, preventing duplicates naturally.
• Use ConcurrentHashMap when you need thread safety in a concurrent environment.

By selecting the right collection for your use case, you can optimize your Java applications for performance, safety, and data integrity.