How to Check if All Map Values Are the Same

Last updated: November 16, 2024

Written by: Sagar Verma

Reviewed by: David Martinez

Java Map

Java HashMap

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Introduction

In this article, we’ll explore various methods for checking if all values in a Java Map are the same. We’ll examine methods such as conventional loops and the Stream API while evaluating their effectiveness and readability.

The practical examples will give us insights into choosing the most effective solution for our applications.

2. Checking if All Values in a Map Are the Same

We’ll review four main strategies. Each uses a different technique to verify if all values in a map are the same. Each strategy has benefits and limitations, so let’s discuss each one in detail.

Let’s create a simple map object that we’ll use throughout the strategies:

Map<String, Integer> map = Map.of("English", 100, "Maths", 100, "Science", 100);

2.1. Using allMatch() With Streams

The allMatch() method, part of Java 8’s Stream API, checks if all elements in a collection satisfy a specified condition. In our case, it checks if all values in the map are equal to the first value in the collection:

boolean areAllValuesSameWithAllMatch(Map<String, Integer> map) {
    int firstValue = map.values().iterator().next();
    return map.values().stream().allMatch(value -> value.equals(firstValue));
}

Here, we get the first value from the map and use allMatch() to verify if every value matches this firstValue. If all values are the same, it returns true. Otherwise, it stops as soon as a different value is found.

2.2. Using a Set to Check for Unique Values

By collecting all values into a HashSet, we take advantage of the fact that the Set automatically removes duplicates:

boolean areAllValuesSameWithSet(Map<String, Integer> map) {
    Set<Integer> uniqueValues = new HashSet<>(map.values());
    return uniqueValues.size() == 1;
}

Here, we collect all values in the Map into a HashSet, which automatically filters out duplicate values. Finally, we check the size of the HashSet. If it’s 1, all values are the same. If it’s greater than 1, there are different values in the Map.

2.3. Using Stream.reduce() With Boolean.logicalAnd

In this method, we use Java Streams reduce() function to combine the values using a logical AND operation, comparing each one to the first value. This method works well if we prefer the functional programming style and don’t require early termination:

boolean areAllValuesSameWithReduce(Map<String, Integer> map) {
    int firstValue = map.values().iterator().next();
    return map.values().stream().reduce(true, 
      (result, value) -> result && value.equals(firstValue), 
      Boolean::logicalAnd);
}

The reduce() method applies Boolean.logicalAnd() across all values. Here, we evaluate each element and reduce it to a true or false value by combining results with Boolean.logicalAnd().

2.4. Using a Traditional for Loop

This approach is ideal if we’re working with pre-Java 8 versions or prefer traditional looping. A straightforward method to use a for-loop to check each value if they’re the same or not:

boolean areAllValuesSameWithLoop(Map<String, Integer> map) {
    int firstValue = map.values().iterator().next();
    for (int value : map.values()) {
        if (!value.equals(firstValue)) {
            return false;
        }
    }
    return true;
}

Here, we retrieve firstValue and compare it with each value in the map with it. Then loop iterates through each value and if a mismatch is detected, the loop exits, and false is returned. Otherwise, the loop returns true once it completes.

3. Performance Comparison

To help us choose the most suitable method for checking all values in a map, we’ve summarised each approach in the table below:

Method	Short-Circuiting	Readability	Compatibility	Efficiency	Performance
allMatch()	Yes	High	Java 8+	Stops as soon as false is found	Optimal for large maps due to early termination
Set-based approach	No	High	Java 7 and below	Efficient for small Maps	Moderate for large Maps due to extra memory for Set creation
reduce with Boolean.logicalAnd()	Yes	Moderate	Java 8+	Processes all values	Less efficient for large Maps due to lack of short-circuiting
Traditional for-loop	Yes	High	Java 7 and below	Stops as soon as false is found	*Optimal for larger Maps* when Java 8+ methods aren’t required

4. Conclusion

In this tutorial, we reviewed four approaches for checking if all values in a Java map are the same. Each approach has specific advantages, from readability and efficiency to compatibility with older Java versions. Our project needs to determine which approach is ideal, and this advice should help us make the best choice.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.