Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

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.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

1. Overview

When working with arrays in Java, there are situations where we need to verify if all elements in an array are equal.

In this tutorial, we’ll explore how to check if all elements in an array are equal in Java.

2. Introduction to the Problem

Checking if all elements in an array are equal sounds straightforward. However, there are some edge cases we need to consider, such as when the array is null or empty, when it only contains one element, when it contains null values, and so on.

Furthermore, in Java, we have object arrays and primitive arrays.

In this tutorial, we’ll cover these scenarios.

Let’s first look at how to check all elements are equal for an object array.

3. Object Arrays

First, let’s list some example arrays whose elements are equal or not:

// all-equal = true arrays:
final static String[] ARRAY_ALL_EQ = { "java", "java", "java", "java" };
final static String[] ARRAY_ALL_NULL = { null, null, null, null };
final static String[] ARRAY_SINGLE_EL = { "java" };
  
// all-equal = false arrays:
final static String[] ARRAY_NOT_EQ = { "java", "kotlin", "java", "java" };
final static String[] ARRAY_EMPTY = {};
final static String[] ARRAY_NULL = null;

As the examples show, if an array contains only one element, we consider all elements equal. However, if an array is null or empty, it contains no elements. Naturally, its elements are not equal.

Next, let’s take these arrays as our inputs to create different methods to perform the check.

3.1. A Loop-Based Generic Method

A straightforward idea is to check each element in the given array in a loop. To make the solution accept all object arrays, we can a generic method:

<T> boolean isAllEqual(T[] array) {
    if (array == null || array.length == 0) {
        return false;
    }
    for (int i = 1; i < array.length; i++) {
        if (!Objects.equals(array[0], array[i])) {
            return false;
        }
    }
    return true;
}

In the isAllEqual() method, we first examine whether the array is empty or null and return the expected result (false). Then, the method checks if all elements in the array are equal by comparing each element to the first element (array[0]). If any element differs, the method returns false; otherwise, it returns true.

It’s worth mentioning that when we compare element values, we use Objects.equals() instead of equals(). This is because the Objects.equals() static method can safely handle null values and won’t raise NullPointerExceptions.

Next, let’s test the method with our array inputs:

assertTrue(isAllEqual(ARRAY_ALL_EQ));
assertTrue(isAllEqual(ARRAY_ALL_NULL));
assertTrue(isAllEqual(ARRAY_SINGLE_EL));
 
assertFalse(isAllEqual(ARRAY_NOT_EQ));
assertFalse(isAllEqual(ARRAY_EMPTY));
assertFalse(isAllEqual(ARRAY_NULL));

The test passes if we give it a run. So, our isAllEqual() solves the problem.

3.2. Using Stream‘s distinct() or allMatch()

Java 1.8 has introduced a significant feature: Stream API. We can use Arrays.stream(array) to convert an array to a Stream, and then use Stream‘s handy methods to manipulate the elements.

Next, we’ll solve the problem using Stream‘s distinct() and allMatch() methods.

distinct() can remove duplicate elements from a Stream. Therefore, we’ll have only one element after distinct() if all elements are equal:

<T> boolean isAllEqualByDistinct(T[] array) {
    // ... null and empty array handling
    return Arrays.stream(array)
      .distinct()
      .count() == 1;
}

As the example shows, the implementation is pretty compact. The following test shows the distinct() approach does the job:

assertTrue(isAllEqualByDistinct(ARRAY_ALL_EQ));
assertTrue(isAllEqualByDistinct(ARRAY_ALL_NULL));
assertTrue(isAllEqualByDistinct(ARRAY_SINGLE_EL));
 
assertFalse(isAllEqualByDistinct(ARRAY_NOT_EQ));
assertFalse(isAllEqualByDistinct(ARRAY_EMPTY));
assertFalse(isAllEqualByDistinct(ARRAY_NULL));

Alternatively, we can also use allMatch() to solve the problem. The allMatch() method checks if all elements in the Stream match a predicate function:

<T> boolean isAllEqualByAllMatch(T[] array) {
     // ... null and empty array handling
    return Arrays.stream(array)
      .allMatch(element -> Objects.equals(array[0], element));
}

This approach passes the same test:

assertTrue(isAllEqualByAllMatch(ARRAY_ALL_EQ));
assertTrue(isAllEqualByAllMatch(ARRAY_ALL_NULL));
assertTrue(isAllEqualByAllMatch(ARRAY_SINGLE_EL));
 
assertFalse(isAllEqualByAllMatch(ARRAY_NOT_EQ));
assertFalse(isAllEqualByAllMatch(ARRAY_EMPTY));
assertFalse(isAllEqualByAllMatch(ARRAY_NULL));

Next, let’s look at how to perform the same check for primitive arrays.

4. Primitive Arrays

We’ve seen different solutions for object arrays. In this section, let’s use int[] as examples to see how to check if all elements in a primitive array are equal.

So next, let’s first create some input examples:

final static int[] INT_ARRAY_ALL_EQ = { 7, 7, 7, 7 };
final static int[] INT_ARRAY_SINGLE_EL = { 42 };
 
final static int[] INT_ARRAY_NOT_EQ = { 7, 7, 7, 42 };

We have omitted null and empty array inputs, as there is no difference from the checks in object array solutions. Further, as primitive elements won’t be null, we don’t have the “ALL_NULL” case.

Next, let’s see how to perform the check on these int[] arrays.

4.1. Using Loop

We can use a quite similar loop-based implementation to check an int[]:

boolean isAllEqual(int[] array) {
    // ... null and empty array handling
    for (int i = 1; i < array.length; i++) {
        if (array[0] != array[i]) {
            return false;
        }
    }
    return true;
}

The above code looks pretty similar to the generic isAllEqual() implementation. However, it’s important to note that we should use ‘==’ to check the equality of two primitive variables.

It’s worth mentioning if we still use Objects.equals() method, the method works too, for example:

if (!Objects.equals(array[0], array[i])) {
    return false;
}

Let’s have a closer look at the Objects.equals() method:

public static boolean equals(Object a, Object b) {
    return (a == b) || (a != null && a.equals(b));
}

As the code shows, Objects.equals() accepts two Object instances. So, when we pass int values to it, int‘ll be autoboxed to its wrapper class Integer. Therefore, we used the ‘!=‘ check directly in our solution to avoid unnecessary autoboxing.

Our solution passes the tests:

assertTrue(isAllEqual(INT_ARRAY_ALL_EQ));
assertTrue(isAllEqual(INT_ARRAY_SINGLE_EL));
 
assertFalse(isAllEqual(INT_ARRAY_NOT_EQ));

To make isAllEqual () work with a different primitive type, we can replace the parameter type int[] with the desired primitive array type.

4.2. Using Stream.distinct() or Stream.allMatch()

Java offers primitive Stream types, such as IntStream, LongStream, etc., which allow us to work with primitive values and the Stream API without autoboxing between the wrapper types.

However, since there is no “ShortStream” class, we can use Arrays.stream(shortArray) to get a Stream of Short instances.

Next, let’s use IntStream‘s distinct() and allMatch() to perform required checks:

//distinct()
boolean isAllEqualByDistinct(int[] array) {
    // ... null and empty array handling
    return IntStream.of(array)
      .distinct()
      .count() == 1;
}

//test:
assertTrue(isAllEqualByDistinct(INT_ARRAY_ALL_EQ));
assertTrue(isAllEqualByDistinct(INT_ARRAY_SINGLE_EL));
 
assertFalse(isAllEqualByDistinct(INT_ARRAY_NOT_EQ));

//allMatch()
boolean isAllEqualByAllMatch(int[] array) {
    // ... null and empty array handling
    return IntStream.of(array)
      .allMatch(element -> array[0] == element));
}

//test:
assertTrue(isAllEqualByAllMatch(INT_ARRAY_ALL_EQ));
assertTrue(isAllEqualByAllMatch(INT_ARRAY_SINGLE_EL));
 
assertFalse(isAllEqualByAllMatch(INT_ARRAY_NOT_EQ));

As the code shows, changing the parameter type to int[] makes the methods work for int[] inputs.

5. Conclusion

In this article, we’ve explored different solutions to checking whether all elements in an array are equal and discussed how to use these approaches to check object and primitive arrays.

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.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW