Método equals() y deepEquals() para comparar dos arrays en Java

es igual() deepEquals()

Arrays.equals(Objeto[], Objeto[]) 

Sintaxis:

public static boolean equals(int[] a, int[] a2)

Parámetros:

• a – una array para probar la igualdad
• a2: la otra array que se probará para la igualdad

Devuelve: verdadero si las dos arrays son iguales

• Retorna True si las arrays son iguales entre sí.
• Si ambas arrays contienen el mismo número de elementos y el mismo elemento en cada índice.
• Además, si ambas arrays son nulas, se consideran iguales.
• El método Arrays.equals() no se compara recursivamente si una array contiene otra array.
• En todos los demás casos, devuelve False.

Array.deepEquals(Objeto[], Objeto[])

Sintaxis:

public static boolean deepEquals(Object[] o1, Object[] o2)

o1 = First Array to test for Equality
o2 = Second Array to test for Equality

• Retorna True si las dos arrays son iguales entre sí.
• Si ambas arrays contienen el mismo número de elementos y el mismo elemento en cada índice.
• Además, ambas arrays son nulas, por lo que se consideran iguales.
• Además, si el elemento anidado es nuevamente una array, los elementos de la array anidada también se comparan de manera iterativa.
• El método Arrays.deepEquals() compara recursivamente si una array contiene otra array.

Principales diferencias:

Si en cualquier Array, un elemento es otro Array en sí mismo, entonces la llamada a equals() va a java.lang.Object equals() predeterminado, que compara la referencia de dos Object y no realiza una comparación profunda y falla la comparación lógica en el caso de Array anidado .

Por otro lado , el método Arrays.deepEquals() realiza muchas comprobaciones y llama a Arrays.equals() para la comparación que no es de array y recursivamente llama a Arrays.deepEquals() para la comparación de tipo de array, lo que le permite comparar arrays anidadas de forma lógica en Java. .  

Nota: siempre se sugiere usar Arrays.equals() para comparar Array no anidado y Arrays.deepEquals() para comparar Array anidado, ya que Array.equals() es más rápido que Arrays.deepEquals() en el caso de no anidado Formación.

Ilustración de equals() en java:

// Java program to compare two arrays
// using .equals() method
  
import java.io.*;
import java.util.*;
  
class GFG {
    public static void main(String[] args)
    {
        int[] A = { 1, 2, 3, 4, 5 };
        int[] B = { 1, 2, 3, 4, 5 };
        int[] C = { 2, 1, 4, 3, 5 };
        
        // Comparing two arrays A and B using .equals()
        if (Arrays.equals(A,B))
            System.out.println(
                "Array A and Array B is equal");
        else
            System.out.println(
                "Array A and Array B is not equal");
  
        if (Arrays.equals(A, C))
            System.out.println(
                "Array A and Array C is equal");
        else
            System.out.println(
                "Array A and Array C is not equal");
    }
}

Array A and Array B is equal
Array A and Array C is not equal

A continuación se muestra una ilustración de deepEquals() en Java: –

// Java program to compare two arrays
// using .deepEquals() method
  
import java.io.*;
import java.util.*;
  
class GFG {
    public static void main(String[] args)
    {
        int[][] A
            = { { 1, 2, 3 }, { 3, 4, 5 }, { 6, 7, 8 } };
        int[][] B
            = { { 1, 2, 3 }, { 3, 4, 5 }, { 6, 7, 8 } };
        int[][] C
            = { { 3, 4, 5 }, { 4, 5, 6 }, { 7, 2, 4 } };
  
        // Comparing A and B arrays using .deepEquals() method
        if (Arrays.deepEquals(A, B))
            System.out.println(
                "Array A and Array B is equal");
        else
            System.out.println(
                "Array A and Array B is not equal");
  
        if (Arrays.deepEquals(A, C))
            System.out.println(
                "Array A and Array C is equal");
        else
            System.out.println(
                "Array A and Array C is not equal");
    }
}

Array A and Array B is equal
Array A and Array C is not equal