Comparar arrays en Java

1. Use el operador == para comparar arrays en Java
2. Utilice el método Arrays.equals() para comparar arrays en Java
3. Utilice el método Arrays.deepEquals() para comparar arrays en Java
4. Use el bucle for para comparar arrays en Java

Hoy escribiremos diferentes fragmentos de código para comparar arrays en Java. Veremos cómo podemos usar el operador ==, Arrays.equals(), Arrays.deepEquals(), y una función personalizada que contiene un bucle for para comparar arrays en Java.

Use el operador == para comparar arrays en Java

Código de ejemplo:

public class compareArrays {
  public static void main(String[] args) {
    int array1[] = {2, 4, 6};
    int array2[] = {2, 4, 6};
    if (array1 == array2)
      System.out.println("Both arrays are the same");
    else
      System.out.println("Both arrays are not the same");
  }
}

Producción :

Both arrays are not the same

En la función main, tenemos dos arrays, array1 y array2, que se refieren a dos objetos diferentes. Entonces, las dos variables de referencia diferentes se comparan, lo que da como resultado Both arrays are not the same.

Utilice el método Arrays.equals() para comparar arrays en Java

Código de ejemplo:

import java.util.Arrays;

public class compareArrays {
  public static void main(String[] args) {
    int array1[] = {2, 4, 6};
    int array2[] = {2, 4, 6};
    if (Arrays.equals(array1, array2))
      System.out.println("Both arrays are the same");
    else
      System.out.println("Both arrays are not the same");
  }
}

Producción :

Both arrays are the same

Este método main también contiene dos arrays denominadas array1 y array2. Aquí, usamos el método Arrays.equals() que reside en Arrays Class y toma dos arrays y compara su contenido.

Supongamos que tenemos dos arrays 2D que necesitamos comparar. ¿Podemos obtener la ventaja del mismo enfoque dado anteriormente para una comparación profunda? No.

En la clase Java Arrays, tenemos varios métodos equals() para tipos primitivos, como int, char, etc. Y un método equals() para la clase Object, pero no podemos usarlo para hacer la comparación profunda para arrays bidimensionales.

Código de ejemplo:

import java.util.Arrays;

public class compareArrays {
  public static void main(String[] args) {
    int innerArray1[] = {2, 4, 6};
    int innerArray2[] = {2, 4, 6};
    Object outerArray1[] = {innerArray1};
    Object outerArray2[] = {innerArray2};

    if (Arrays.equals(outerArray1, outerArray2))
      System.out.println("Both arrays are the same");
    else
      System.out.println("Both arrays are not the same");
  }
}

Producción :

Both arrays are not the same

Podemos usar el método deepEquals() para una comparación profunda, lo cual es útil si tenemos arrays bidimensionales.

Utilice el método Arrays.deepEquals() para comparar arrays en Java

Código de ejemplo:

import java.util.Arrays;

public class compareArrays {
  public static void main(String[] args) {
    int innerArray1[] = {2, 4, 6};
    int innerArray2[] = {2, 4, 6};
    Object outerArray1[] = {innerArray1};
    Object outerArray2[] = {innerArray2};

    if (Arrays.deepEquals(outerArray1, outerArray2))
      System.out.println("Both arrays are the same");
    else
      System.out.println("Both arrays are not the same");
  }
}

Producción :

Both arrays are the same

El método deepEquals() funciona bien para una comparación profunda. El método Arrays.deepEquals() comprueba si dos arrays son iguales o no.

Estas dos arrays pueden ser una, dos o incluso multidimensionales.

¿Cómo decide este método si las arrays proporcionadas son iguales o no? Para ello, debes tener en cuenta los siguientes puntos:

• Si las referencias de ambas arrays proporcionadas son nulas, las arrays serían profundamente iguales.
• Podemos declarar dos arrays de referencia profundamente iguales si apuntan a las arrays que contienen el número exacto de elementos y los pares de elementos correspondientes.
• Dos elementos, element1 y element2 que posiblemente sean nulos, serían profundamente iguales si se cumple cualquiera de las condiciones de la siguiente lista:
  • El Arrays.deepEquals(element1, element2) devuelve verdadero si el tipo de ambos arrays es una referencia de objeto.
  • El Arrays.equals(element1, element2) devuelve verdadero si ambas arrays son del mismo tipo primitivo.
  • element1 == element2
  • element1.equals(element2) devuelve verdadero.

Use el bucle for para comparar arrays en Java

Código de ejemplo:

public class compareArrays {
  public static boolean compare(int[] array1, int[] array2) {
    boolean flag = true;

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

    return flag;
  }

  public static void main(String[] args) {
    int array1[] = {2, 4, 6};
    int array2[] = {2, 4, 6};

    if (compare(array1, array2))
      System.out.println("Both arrays are the same");
    else
      System.out.println("Both arrays are not the same");
  }
}

Producción :

Both arrays are the same

Aquí, escribimos una función compare() que toma dos arrays del tipo int. Los compara a nivel de elemento individual utilizando el bucle for y devuelve verdadero si ambos arrays son iguales; en caso contrario, falso.