Comparar dos arreglos en Java

Al comparar dos arrays, no podemos usar el operador «==», ya que comparará las direcciones del bloque de memoria al que apuntan ambas arrays. Si queremos comparar los elementos dentro de la array, debemos encontrar otras formas en lugar de usar operadores aritméticos. Como todos sabemos, las estructuras de datos de arrays poseen la propiedad de contener elementos de manera continua, por lo que podemos calcular el tamaño de ambas arrays utilizando el método size() de la propia clase Arrays, y podemos comenzar a comparar los índices si el tamaño de se encuentra que ambas arrays son iguales.

Ilustración:

// Java Program to Illustrate
// Comparison of Arrays
// Using == Operators
 
// Importing required classes
import java.util.*;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Declaring integer arrays and
        // initializing them with custom values
        int arr1[] = { 1, 2, 3 };
        int arr2[] = { 1, 2, 3 };
 
        // Comparing arrays if equal or not
        // using == operator
        if (arr1 == arr2)
 
            // Print statement
            System.out.println("Same");
        else
 
            // Print statement
            System.out.println("Not same");
    }
}

Not same

Explicación de salida: en Java, las arrays son objetos de primera clase . En el programa anterior, arr1 y arr2 son dos referencias a dos objetos diferentes. Entonces, cuando comparamos arr1 y arr2, se comparan dos variables de referencia, por lo tanto, obtenemos el resultado como «No es lo mismo».

¿Cómo comparar el contenido de la array? 

Una forma sencilla es ejecutar un ciclo y comparar los elementos uno por uno. Java proporciona un método directo Arrays.equals() para comparar dos arrays. En realidad, hay una lista de métodos equals() en la clase Arrays para diferentes tipos primitivos (int, char, ..etc) y uno para el tipo Object (que es la base de todas las clases en Java). 

Ejemplo:

// Java Program to Check If Two Arrays Are Equal
// Using equals() method of Arrays class
 
// Importing required classes
import java.util.Arrays;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Declaring integer arrays
        int arr1[] = { 1, 2, 3 };
        int arr2[] = { 1, 2, 3 };
 
        // Checking if above two arrays are equal
        // using equals() method
        if (Arrays.equals(arr1, arr2))
 
            // Print statement if arrays are equal
            System.out.println("Same");
        else
 
            // Print statement if arrays are equal
            System.out.println("Not same");
    }
}

Same

Explicación de salida: como se ve arriba, Arrays.equals() funciona bien y compara los contenidos de las arrays. Ahora la pregunta, ¿qué pasa si las arrays contienen arrays dentro de ellas o algunas otras referencias que se refieren a diferentes objetos pero tienen los mismos valores? Por ejemplo, consulte el siguiente programa de la siguiente manera.

¿Cómo hacer una comparación profunda de los contenidos de la array?   

Ejemplo 1-A:

// Java Program to Check If Two Arrays Are Equal
// Using equals() method of Arrays class
 
// Importing required classes
import java.util.Arrays;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Declaring and initializing integer arrays
        // having same values
 
        // Array 1
        int inarr1[] = { 1, 2, 3 };
        // // Array 2
        int inarr2[] = { 1, 2, 3 };
 
        // // Array 1 contains only one element
        Object[] arr1 = { inarr1 };
        // Array 2 also contains only one element
        Object[] arr2 = { inarr2 };
 
        // Checking if arrays are equal or not
        // using equals() method
        if (Arrays.equals(arr1, arr2))
 
            // Print statement if arrays are same
            System.out.println("Same");
        else
 
            // Print statement if arrays are not same
            System.out.println("Not same");
    }
}

Not same

Explicación de salida: Entonces Arrays.equals() no puede hacer una comparación profunda. Java proporciona otro método para este Arrays.deepEquals() que hace la comparación profunda.

Ejemplo 1-B:

// Java Program to Check If Two Arrays Are Equal
// Using deepEquals() method of Arrays class
 
// Importing required classes
import java.util.Arrays;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Declaring and initializing integer arrays
        // having same values
 
        // Array 1
        int inarr1[] = { 1, 2, 3 };
        // Array 2
        int inarr2[] = { 1, 2, 3 };
 
        // Array 1 contains only one element
        Object[] arr1 = { inarr1 };
        // Array 2 also contains only one element
        Object[] arr2 = { inarr2 };
 
        // Checking if arrays are equal or not
        // using deepEquals() method
        if (Arrays.deepEquals(arr1, arr2))
 
            // Print statement if arrays are same
            System.out.println("Same");
        else
 
            // Print statement if arrays are not same
            System.out.println("Not same");
    }
}

Same

Salida Explicación: Ahora comprendamos cómo funciona internamente el método doesdeepEquals() de la clase Arrays . Compara dos objetos utilizando cualquier método equals() personalizado que puedan tener (si tienen un método equals() implementado que no sea Object.equals()). De no ser así, este método procederá entonces a comparar los objetos campo por campo, recursivamente. A medida que se encuentra cada campo, intentará usar el equals() derivado si existe; de ​​lo contrario, continuará repitiéndose más. 

Este método funciona en un gráfico de objeto cíclico como este: A->B->C->A. Tiene detección de ciclo, por lo que se pueden comparar CUALQUIER dos objetos, y nunca entrará en un ciclo sin fin.

Ejemplo 1-C:  

// Java Program to Check If Two Arrays Are Equal
// Using deepEquals() method of Arrays class
 
// Importing required classes
import java.util.Arrays;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Declaring and initializing integer arrays
        // having same values
 
        // Array 1
        int inarr1[] = { 1, 2, 3 };
        // Array 2
        int inarr2[] = { 1, 2, 3 };
 
        // Array 1 contains only one element
        Object[] arr1 = { inarr1 };
        // Array 2 also contains only one element
        Object[] arr2 = { inarr2 };
 
        // outarr1 contains only one element
        Object[] outarr1 = { arr1 };
        // outarr2 also contains only one element
        Object[] outarr2 = { arr2 };
 
        // Checking if arrays are equal or not
        // using deepEquals() method
        if (Arrays.deepEquals(outarr1, outarr2))
 
            // Print statement if arrays are same
            System.out.println("Same");
        else
 
            // Print statement if arrays are not same
            System.out.println("Not same");
    }
}

Same

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.