Program To Check If Two Arrays Are Equal Or Not In Java

When comparing data structures, a common task is to determine if two arrays contain the same elements in the same order. This check is fundamental in various programming scenarios, from data validation to testing. In this article, you will learn multiple approaches to efficiently check for array equality in Java.

Problem Statement

The problem is to ascertain whether two given arrays are identical. For two arrays to be considered equal, two conditions must be met:

1. They must have the same number of elements (i.e., the same length).
2. All corresponding elements at each index must be equal.

This is critical in scenarios like validating user input against a known set of values, comparing test results, or ensuring data integrity after serialization/deserialization.

Example

Consider these two integer arrays:

int[] arrayA = {10, 20, 30}; int[] arrayB = {10, 20, 30};

These arrays are considered equal because they have the same length and all elements at corresponding positions are identical.

However, consider these:

int[] arrayC = {10, 20, 30}; int[] arrayD = {10, 30, 20};

These arrays are not equal, even though they contain the same numbers, because the order of elements is different.

int[] arrayE = {10, 20}; int[] arrayF = {10, 20, 30};

These arrays are not equal because they have different lengths.

Background & Knowledge Prerequisites

To understand the solutions presented, familiarity with the following Java concepts is beneficial:

• Arrays: Basic understanding of how arrays are declared, initialized, and accessed.
• Loops: for loops for iterating through collections.
• Conditional Statements: if-else constructs for decision-making.
• Methods: Defining and calling methods.
• Object Equality: The difference between == (reference equality) and .equals() (content equality) for objects. For primitive types, == compares values directly. For object types (like String, Integer, custom objects), equals() method should be used for value comparison.

Use Cases or Case Studies

Checking array equality is useful in many real-world applications:

• Configuration Validation: Verifying that a loaded configuration (e.g., a list of authorized users or settings) matches a baseline or expected configuration.
• Testing and Assertions: In unit tests, asserting that the actual output (an array) from a function matches the expected output array.
• Data Integrity Checks: After transmitting or storing an array of data, comparing the received/retrieved array with the original to ensure no corruption occurred.
• Game Development: Comparing player inventory arrays, level state arrays, or puzzle solution arrays.
• Algorithm Verification: Confirming that sorting algorithms produce identical sorted arrays, or that search algorithms correctly identify elements within a subset.

Solution Approaches

Here are several ways to check if two arrays are equal in Java, each suitable for different scenarios or preferences.

Approach 1: Manual Iteration with a Loop

This approach involves manually checking both the lengths of the arrays and then iterating through them element by element. This gives the most control and demonstrates the underlying logic.

• Summary: Compare array lengths first; if they differ, arrays are unequal. Otherwise, iterate through both arrays, comparing elements at each corresponding index. If any elements differ, the arrays are unequal. If the loop completes, they are equal.
• Code Example:

// ArrayEqualityManualCheck
import java.util.Scanner; // Not strictly needed for this example, but common import

public class Main {
    public static boolean areArraysEqualManually(int[] arr1, int[] arr2) {
        // Step 1: Check if arrays are null.
        // If both are null, they are considered equal.
        // If one is null and the other isn't, they are unequal.
        if (arr1 == null && arr2 == null) {
            return true;
        }
        if (arr1 == null || arr2 == null) {
            return false;
        }

        // Step 2: Check if arrays have the same length
        if (arr1.length != arr2.length) {
            return false; // Lengths are different, so arrays are not equal
        }

        // Step 3: Iterate through elements and compare
        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] != arr2[i]) {
                return false; // Found a differing element, so arrays are not equal
            }
        }

        // Step 4: If loop completes, all elements were equal
        return true;
    }

    public static void main(String[] args) {
        int[] array1 = {10, 20, 30, 40};
        int[] array2 = {10, 20, 30, 40};
        int[] array3 = {10, 20, 50, 40};
        int[] array4 = {10, 20, 30};
        int[] array5 = null;
        int[] array6 = null;

        System.out.println("array1 and array2 are equal: " + areArraysEqualManually(array1, array2));
        System.out.println("array1 and array3 are equal: " + areArraysEqualManually(array1, array3));
        System.out.println("array1 and array4 are equal: " + areArraysEqualManually(array1, array4));
        System.out.println("array5 and array6 are equal: " + areArraysEqualManually(array5, array6));
        System.out.println("array1 and array5 are equal: " + areArraysEqualManually(array1, array5));

        // Example with String arrays (requires .equals() for elements)
        String[] sArray1 = {"apple", "banana"};
        String[] sArray2 = {"apple", "banana"};
        String[] sArray3 = {"apple", "null"}; // Note: "null" as a string
        String[] sArray4 = {"orange", "banana"};

        System.out.println("\\n--- String Array Examples ---");
        System.out.println("sArray1 and sArray2 are equal: " + areStringArraysEqualManually(sArray1, sArray2));
        System.out.println("sArray1 and sArray4 are equal: " + areStringArraysEqualManually(sArray1, sArray4));
    }

    // Helper for String arrays, showing use of .equals()
    public static boolean areStringArraysEqualManually(String[] arr1, String[] arr2) {
        if (arr1 == null && arr2 == null) {
            return true;
        }
        if (arr1 == null || arr2 == null) {
            return false;
        }
        if (arr1.length != arr2.length) {
            return false;
        }
        for (int i = 0; i < arr1.length; i++) {
            // Use Objects.equals to handle potential null elements gracefully
            if (!java.util.Objects.equals(arr1[i], arr2[i])) {
                return false;
            }
        }
        return true;
    }
}

Run

• Sample Output:

array1 and array2 are equal: true
array1 and array3 are equal: false
array1 and array4 are equal: false
array5 and array6 are equal: true
array1 and array5 are equal: false

--- String Array Examples ---
sArray1 and sArray2 are equal: true
sArray1 and sArray4 are equal: false

• Stepwise Explanation:

1. Handle Nulls: First, check if either or both arrays are null. If both are null, they are considered equal. If one is null and the other is not, they are unequal.
2. Compare Lengths: Check if arr1.length is equal to arr2.length. If lengths differ, the arrays cannot be equal, so return false immediately.
3. Element-by-Element Comparison: Use a for loop to iterate from index 0 up to arr1.length - 1.
4. Primitive vs. Object: Inside the loop, for primitive arrays (like int[]), compare elements using !=. For object arrays (like String[], Integer[], or custom objects), use !java.util.Objects.equals(arr1[i], arr2[i]) to handle potential null elements safely and compare their content.
5. Return False on Mismatch: If at any point arr1[i] is not equal to arr2[i], return false.
6. Return True if Loop Completes: If the loop finishes without finding any differences, it means all elements are identical, and the arrays are equal; return true.

Approach 2: Using java.util.Arrays.equals() Method

Java provides a utility method in the java.util.Arrays class specifically for comparing arrays. This is the recommended approach for most single-dimensional array comparisons.

• Summary: The Arrays.equals() method directly compares two arrays. It handles null checks, length comparisons, and element-by-element comparisons, including proper handling for object arrays using their equals() method.
• Code Example:

// ArrayEqualityArraysEquals
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // Primitive arrays (e.g., int[])
        int[] arrP1 = {1, 2, 3};
        int[] arrP2 = {1, 2, 3};
        int[] arrP3 = {1, 3, 2};
        int[] arrP4 = {1, 2};

        System.out.println("--- Primitive Array Examples (int[]) ---");
        System.out.println("arrP1 and arrP2 equal: " + Arrays.equals(arrP1, arrP2));
        System.out.println("arrP1 and arrP3 equal: " + Arrays.equals(arrP1, arrP3));
        System.out.println("arrP1 and arrP4 equal: " + Arrays.equals(arrP1, arrP4));

        // Object arrays (e.g., String[])
        String[] arrS1 = {"apple", "banana", "cherry"};
        String[] arrS2 = {"apple", "banana", "cherry"};
        String[] arrS3 = {"apple", "orange", "cherry"};
        String[] arrS4 = {"apple", "banana"};
        String[] arrS5 = {"apple", null, "cherry"};
        String[] arrS6 = {"apple", null, "cherry"};

        System.out.println("\\n--- Object Array Examples (String[]) ---");
        System.out.println("arrS1 and arrS2 equal: " + Arrays.equals(arrS1, arrS2));
        System.out.println("arrS1 and arrS3 equal: " + Arrays.equals(arrS1, arrS3));
        System.out.println("arrS1 and arrS4 equal: " + Arrays.equals(arrS1, arrS4));
        System.out.println("arrS5 and arrS6 equal: " + Arrays.equals(arrS5, arrS6)); // Handles null elements correctly

        // Arrays with null references
        int[] nullArr1 = null;
        int[] nullArr2 = null;
        int[] nonNullArr = {1, 2};

        System.out.println("\\n--- Null Array Examples ---");
        System.out.println("nullArr1 and nullArr2 equal: " + Arrays.equals(nullArr1, nullArr2));
        System.out.println("nullArr1 and nonNullArr equal: " + Arrays.equals(nullArr1, nonNullArr));

        // For multi-dimensional arrays, Arrays.equals() does a shallow comparison
        // It compares the references of the inner arrays, not their content.
        // For deep comparison of multi-dimensional arrays, use Arrays.deepEquals().
        int[][] multiArr1 = {{1, 2}, {3, 4}};
        int[][] multiArr2 = {{1, 2}, {3, 4}};
        int[][] multiArr3 = {{1, 2}, {3, 5}};

        System.out.println("\\n--- Multi-dimensional Array Note ---");
        System.out.println("multiArr1 and multiArr2 (shallow) equal: " + Arrays.equals(multiArr1, multiArr2)); // This will be false!
        System.out.println("multiArr1 and multiArr2 (deep) equal: " + Arrays.deepEquals(multiArr1, multiArr2));
        System.out.println("multiArr1 and multiArr3 (deep) equal: " + Arrays.deepEquals(multiArr1, multiArr3));
    }
}

Run

• Sample Output:

--- Primitive Array Examples (int[]) ---
arrP1 and arrP2 equal: true
arrP1 and arrP3 equal: false
arrP1 and arrP4 equal: false

--- Object Array Examples (String[]) ---
arrS1 and arrS2 equal: true
arrS1 and arrS3 equal: false
arrS1 and arrS4 equal: false
arrS5 and arrS6 equal: true

--- Null Array Examples ---
nullArr1 and nullArr2 equal: true
nullArr1 and nonNullArr equal: false

--- Multi-dimensional Array Note ---
multiArr1 and multiArr2 (shallow) equal: false
multiArr1 and multiArr2 (deep) equal: true
multiArr1 and multiArr3 (deep) equal: false

• Stepwise Explanation:

1. Import: Ensure import java.util.Arrays; is at the top of your Java file.
2. Call Arrays.equals(): Simply pass the two arrays you want to compare to the Arrays.equals() method: Arrays.equals(array1, array2).
3. Return Value: The method returns true if the arrays are equal (same length, same elements in the same order), and false otherwise.
4. Primitive vs. Object: Arrays.equals() is overloaded for all primitive array types (int[], char[], boolean[], etc.) where it compares elements using ==. For object arrays (Object[], String[], etc.), it iterates and compares elements using their respective .equals() methods, correctly handling null elements within the array.
5. Multi-dimensional Arrays: For multi-dimensional arrays (e.g., int[][]), Arrays.equals() performs a shallow comparison, meaning it checks if the references to the inner arrays are identical. To compare the *contents* of multi-dimensional arrays, use Arrays.deepEquals(array1, array2).

Approach 3: Using Java Stream API (Java 8+)

For a more functional style, Java 8's Stream API can also be used, particularly effective for object arrays or when combined with other stream operations. This approach is more concise but might be less readable for beginners.

• Summary: Convert the arrays into streams and then use stream operations to compare elements. This typically involves checking lengths and then verifying that all elements at corresponding indices are equal.
• Code Example:

// ArrayEqualityStreamAPI
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream; // For primitive int arrays

public class Main {
    public static <T> boolean areArraysEqualStream(T[] arr1, T[] arr2) {
        // Step 1: Handle null arrays
        if (arr1 == null && arr2 == null) {
            return true;
        }
        if (arr1 == null || arr2 == null) {
            return false;
        }

        // Step 2: Check if arrays have the same length
        if (arr1.length != arr2.length) {
            return false;
        }

        // Step 3: Compare elements using streams
        // IntStream.range creates a stream of indices (0 to length-1)
        // allMatch checks if all elements satisfy the given predicate
        return IntStream.range(0, arr1.length)
                        .allMatch(i -> java.util.Objects.equals(arr1[i], arr2[i]));
    }

    public static boolean areIntArraysEqualStream(int[] arr1, int[] arr2) {
        // Step 1: Handle null arrays
        if (arr1 == null && arr2 == null) {
            return true;
        }
        if (arr1 == null || arr2 == null) {
            return false;
        }

        // Step 2: Check if arrays have the same length
        if (arr1.length != arr2.length) {
            return false;
        }

        // Step 3: Compare elements using streams (for primitives)
        // For primitive arrays, direct == comparison is usually fine
        return IntStream.range(0, arr1.length)
                        .allMatch(i -> arr1[i] == arr2[i]);
    }

    public static void main(String[] args) {
        Integer[] objArr1 = {1, 2, 3};
        Integer[] objArr2 = {1, 2, 3};
        Integer[] objArr3 = {1, 3, 2};
        Integer[] objArr4 = {1, null, 3};
        Integer[] objArr5 = {1, null, 3};

        System.out.println("--- Object Array Examples (Integer[]) ---");
        System.out.println("objArr1 and objArr2 equal: " + areArraysEqualStream(objArr1, objArr2));
        System.out.println("objArr1 and objArr3 equal: " + areArraysEqualStream(objArr1, objArr3));
        System.out.println("objArr4 and objArr5 equal: " + areArraysEqualStream(objArr4, objArr5));

        int[] intArr1 = {10, 20, 30};
        int[] intArr2 = {10, 20, 30};
        int[] intArr3 = {10, 20, 40};

        System.out.println("\\n--- Primitive Array Examples (int[]) ---");
        System.out.println("intArr1 and intArr2 equal: " + areIntArraysEqualStream(intArr1, intArr2));
        System.out.println("intArr1 and intArr3 equal: " + areIntArraysEqualStream(intArr1, intArr3));
    }
}

Run

• Sample Output:

--- Object Array Examples (Integer[]) ---
objArr1 and objArr2 equal: true
objArr1 and objArr3 equal: false
objArr4 and objArr5 equal: true

--- Primitive Array Examples (int[]) ---
intArr1 and intArr2 equal: true
intArr1 and intArr3 equal: false

• Stepwise Explanation:

1. Handle Nulls and Length: Similar to manual iteration, first handle null arrays and compare lengths. If lengths differ, return false.
2. Create an IntStream of Indices: Use IntStream.range(0, arr1.length) to generate a stream of integers representing the indices of the arrays.
3. allMatch Predicate: Apply the allMatch() terminal operation on this stream. allMatch() takes a Predicate (a function that returns boolean).
4. Element Comparison: The predicate i -> java.util.Objects.equals(arr1[i], arr2[i]) compares elements at the current index i. For object arrays, Objects.equals() is used for safe and correct comparison, handling null elements. For primitive arrays, i -> arr1[i] == arr2[i] is appropriate.
5. Return Value: allMatch() returns true if the predicate is true for all elements in the stream (meaning all corresponding array elements are equal), and false otherwise.

Conclusion

Checking array equality in Java is a frequent operation with several efficient approaches. While manual iteration provides granular control and a clear understanding of the underlying logic, the java.util.Arrays.equals() method is generally the most concise and robust solution for comparing single-dimensional arrays, handling both primitive and object types correctly. For multi-dimensional arrays, Arrays.deepEquals() is the go-to. The Stream API offers a more functional and expressive alternative for those familiar with Java 8 features. Choosing the right method depends on the array type, complexity, and desired readability.

Summary

• Array Equality Definition: Two arrays are equal if they have the same length and all corresponding elements are identical.
• Manual Iteration: Involves explicit null checks, length comparison, and then a loop for element-by-element comparison. Use == for primitives and Objects.equals() for objects.
• Arrays.equals(): The standard library method for comparing single-dimensional arrays. It handles nulls, length, and element comparisons (using == for primitives, .equals() for objects) efficiently.
• Arrays.deepEquals(): Essential for comparing the *contents* of multi-dimensional arrays, as Arrays.equals() only performs a shallow comparison for these.
• Stream API: Provides a functional approach using IntStream.range().allMatch() for comparing elements, requiring manual null and length checks beforehand.
• Best Practice: For single-dimensional arrays, Arrays.equals() is usually the most readable and efficient choice.