Comparing Two HashMap in Java

HashMaps are a fundamental data structure in Java used to store key-value pairs. They offer fast and efficient access to values by key, making them a popular choice for various applications. Often, you may need to compare two HashMaps to identify differences or similarities. In this section, we will explore different approaches to compare two HashMaps in Java.

Initializing Two HashMaps

Before we compare two HashMaps, we need to create them.

HashMapComparison.java

import java.util.HashMap;
import java.util.Map;
public class HashMapComparison {
    public static void main(String[] args) {
        Map<Integer, String> map1 = new HashMap<>();
        map1.put(1, "Apple");
        map1.put(2, "Banana");
        map1.put(3, "Cherry");
        Map<Integer, String> map2 = new HashMap<>();
        map2.put(1, "Apple");
        map2.put(2, "Banana");
        map2.put(4, "Date");
    }
}

In this example, map1 and map2 are two HashMaps with key-value pairs. map1 has keys 1, 2, and 3, while map2 has keys 1, 2, and 4.

Comparing HashMaps

Comparing Key Sets:

The most straightforward way to compare two HashMaps is by comparing their key sets. We can do this using the keySet() method, and then checking if the key sets are equal.

The approach only checks if the sets of keys in both HashMaps are identical. It doesn't consider the values associated with those keys. If we want to check for key-value pairs, we will need a more comprehensive approach.

Comparing Key-Value Pairs:

To compare the key-value pairs in two HashMaps, we can iterate through one of the HashMaps and verify if each key-value pair exists in the other HashMap.

boolean areEqual = true;
for (Map.Entry<Integer, String> entry : map1.entrySet()) {
    Integer key = entry.getKey();
    String value = entry.getValue();
    if (!map2.containsKey(key) || !map2.get(key).equals(value)) {
        areEqual = false;
        break;
    }
}
if (areEqual) {
    for (Map.Entry<Integer, String> entry : map2.entrySet()) {
        Integer key = entry.getKey();
        String value = entry.getValue();
        if (!map1.containsKey(key) || !map1.get(key).equals(value)) {
            areEqual = false;
            break;
        }
    }
}

The code checks if both maps contain the same key-value pairs. If any difference is found, the areEqual flag is set to false. After the loops, if areEqual remains true, the two HashMaps are considered equal.

Using Apache Commons Collections:

Apache Commons Collections is a popular library that provides utilities for working with collections in Java. The MapUtils class in this library offers a handy method called isEqualMap(). We can use it to compare two maps with ease:

import org.apache.commons.collections4.MapUtils;
boolean areEqual = MapUtils.isEqualMap(map1, map2);

The approach is more concise and readable, but it requires adding the Apache Commons Collections library to your project.

Here's the complete Java code to compare two HashMaps using different approaches, along with the expected output:

File Name: HashMapComparison.java

import java.util.HashMap;
import java.util.Map;
import org.apache.commons.collections4.MapUtils;
public class HashMapComparison {
    public static void main(String[] args) {
        // Initialize two HashMaps
        Map<Integer, String> map1 = new HashMap<>();
        map1.put(1, "Apple");
        map1.put(2, "Banana");
        map1.put(3, "Cherry");
        Map<Integer, String> map2 = new HashMap<>();
        map2.put(1, "Apple");
        map2.put(2, "Banana");
        map2.put(4, "Date");
        // Compare using key sets
        boolean areEqualKeys = map1.keySet().equals(map2.keySet());
        System.out.println("Comparing by key sets: " + areEqualKeys);
        // Compare using key-value pairs
        boolean areEqualPairs = true;
        for (Map.Entry<Integer, String> entry : map1.entrySet()) {
            Integer key = entry.getKey();
            String value = entry.getValue();
            if (!map2.containsKey(key) || !map2.get(key).equals(value)) {
                areEqualPairs = false;
                break;
            }
        }
        if (areEqualPairs) {
            for (Map.Entry<Integer, String> entry : map2.entrySet()) {
                Integer key = entry.getKey();
                String value = entry.getValue();
                if (!map1.containsKey(key) || !map1.get(key).equals(value)) {
                    areEqualPairs = false;
                    break;
                }
            }
        }
        System.out.println("Comparing by key-value pairs: " + areEqualPairs);
        // Compare using Apache Commons Collections
        boolean areEqualCommons = MapUtils.isEqualMap(map1, map2);
        System.out.println("Comparing using Apache Commons Collections: " + areEqualCommons);
    }
}

Expected Output:

Comparing by key sets: false
Comparing by key-value pairs: false
Comparing using Apache Commons Collections: false

In this code, we initialize two HashMaps (map1 and map2) with different key-value pairs. The program then compares these HashMaps using three different approaches and prints the results. In this case, all three methods indicate that the two HashMaps are not equal because they have different keys and values.

Conclusion

Comparing two HashMaps in Java can be done in various ways, depending on your specific requirements. We can compare key sets for a quick check, compare key-value pairs for a more in-depth analysis, or leverage libraries like Apache Commons Collections for simplicity and conciseness.

Choosing the right approach depends on the complexity of data and the performance considerations of our application. Ensure that, select the method that best suits to our needs to accurately compare the HashMap and achieve the desired results in our Java application.

Next TopicCryptosystem Project in Java

← prev next →