Java Program to Check Two Arrays are Equal

Introduction

In Java, checking if two arrays are equal is a common task. There are multiple ways to achieve this, each with its own advantages and use cases. Here, we will discuss different methods for comparing arrays for equality, including using the Arrays.equals() method, a manual comparison approach, and deep equality checks for multi-dimensional arrays.

Methods to Check Array Equality

1. Using Arrays.equals()
2. Using Manual Comparison
3. Using Arrays.deepEquals() for Multi-Dimensional Arrays
4. Using Arrays.mismatch()

1. Using Arrays.equals()

The Arrays.equals() method is the simplest way to compare two arrays. It compares the length of the arrays and each element for equality.

Example:

import java.util.Arrays;

public class ArraysEqualsExample {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3, 4, 5};
        int[] array2 = {1, 2, 3, 4, 5};
        int[] array3 = {5, 4, 3, 2, 1};

        boolean isEqual = Arrays.equals(array1, array2);
        System.out.println("Array1 equals Array2: " + isEqual);

        isEqual = Arrays.equals(array1, array3);
        System.out.println("Array1 equals Array3: " + isEqual);
    }
}

Output:

Array1 equals Array2: true
Array1 equals Array3: false

Explanation: Arrays.equals(array1, array2) returns true if both arrays have the same length and corresponding elements.

2. Using Manual Comparison

A manual comparison involves iterating through the arrays and comparing each element.

Example:

public class ManualArrayEqualityCheck {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3, 4, 5};
        int[] array2 = {1, 2, 3, 4, 5};
        int[] array3 = {5, 4, 3, 2, 1};

        boolean isEqual = areArraysEqual(array1, array2);
        System.out.println("Array1 equals Array2 (manual): " + isEqual);

        isEqual = areArraysEqual(array1, array3);
        System.out.println("Array1 equals Array3 (manual): " + isEqual);
    }

    public static boolean areArraysEqual(int[] array1, int[] array2) {
        if (array1.length != array2.length) {
            return false;
        }

        for (int i = 0; i < array1.length; i++) {
            if (array1[i] != array2[i]) {
                return false;
            }
        }

        return true;
    }
}

Output:

Array1 equals Array2 (manual): true
Array1 equals Array3 (manual): false

Explanation: This method manually checks if both arrays have the same length and compares each element. If all elements match, the arrays are considered equal.

3. Using Arrays.deepEquals() for Multi-Dimensional Arrays

For multi-dimensional arrays, use Arrays.deepEquals() to perform a deep comparison, which checks the equality of nested arrays.

Example:

import java.util.Arrays;

public class DeepEqualsExample {
    public static void main(String[] args) {
        int[][] matrix1 = {
            {1, 2, 3},
            {4, 5, 6}
        };
        int[][] matrix2 = {
            {1, 2, 3},
            {4, 5, 6}
        };
        int[][] matrix3 = {
            {7, 8, 9},
            {10, 11, 12}
        };

        boolean isEqual = Arrays.deepEquals(matrix1, matrix2);
        System.out.println("Matrix1 equals Matrix2: " + isEqual);

        isEqual = Arrays.deepEquals(matrix1, matrix3);
        System.out.println("Matrix1 equals Matrix3: " + isEqual);
    }
}

Output:

Matrix1 equals Matrix2: true
Matrix1 equals Matrix3: false

Explanation: Arrays.deepEquals(matrix1, matrix2) compares each nested array for equality, making it suitable for multi-dimensional arrays.

4. Using Arrays.mismatch()

The Arrays.mismatch() method finds and returns the index of the first mismatch between two arrays. If there are no mismatches, it returns -1.

Example:

import java.util.Arrays;

public class ArraysMismatchExample {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3, 4, 5};
        int[] array2 = {1, 2, 3, 4, 6};
        int[] array3 = {1, 2, 3, 4, 5};

        int mismatchIndex = Arrays.mismatch(array1, array2);
        System.out.println("First mismatch between array1 and array2: " + mismatchIndex);

        mismatchIndex = Arrays.mismatch(array1, array3);
        System.out.println("First mismatch between array1 and array3: " + mismatchIndex);
    }
}

Output:

First mismatch between array1 and array2: 4
First mismatch between array1 and array3: -1

Explanation: The Arrays.mismatch() method returns the index of the first differing element. If the arrays are identical, it returns -1.

Conclusion

There are multiple ways to check the equality of arrays in Java:

1. Using Arrays.equals(): Simple and effective for one-dimensional arrays.
2. Using Manual Comparison: Provides more control and understanding of the comparison process.
3. Using Arrays.deepEquals(): Essential for comparing multi-dimensional arrays.
4. Using Arrays.mismatch(): Useful for identifying the position of the first mismatch.

Each method has its own use case and advantages. Understanding these techniques helps you effectively compare arrays based on the requirements of your Java programs.