Comparer les tableaux en Java

1. Utilisez l’opérateur == pour comparer les tableaux en Java
2. Utilisez la méthode Arrays.equals() pour comparer les tableaux en Java
3. Utilisez la méthode Arrays.deepEquals() pour comparer les tableaux en Java
4. Utiliser la boucle for pour comparer des tableaux en Java

Aujourd’hui, nous allons écrire différents extraits de code pour comparer les tableaux en Java. Nous verrons comment utiliser l’opérateur ==, Arrays.equals(), Arrays.deepEquals(), et une fonction personnalisée contenant une boucle for pour comparer des tableaux en Java.

Utilisez l’opérateur == pour comparer les tableaux en Java

Exemple de code :

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");
  }
}

Production:

Both arrays are not the same

Dans la fonction main, nous avons deux tableaux, array1 et array2, faisant référence à deux objets différents. Ainsi, les deux variables de référence différentes sont comparées, ce qui donne Both arrays are not the same.

Utilisez la méthode Arrays.equals() pour comparer les tableaux en Java

Exemple de code :

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");
  }
}

Production:

Both arrays are the same

Cette méthode main contient également deux tableaux nommés array1 et array2. Ici, nous utilisons la méthode Arrays.equals() qui réside dans Arrays Class et prend deux tableaux et compare leur contenu.

Supposons que nous ayons deux tableaux 2D que nous devons comparer. Pouvons-nous tirer parti de la même approche que celle indiquée ci-dessus pour une comparaison approfondie ? Non.

Dans la classe Java Arrays, nous avons diverses méthodes equals() pour les types primitifs, tels que int, char, etc. Et une méthode equals() pour la classe Object, mais nous ne pouvons pas l’utiliser pour faire la comparaison approfondie pour les tableaux à deux dimensions.

Exemple de code :

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");
  }
}

Production:

Both arrays are not the same

Nous pouvons utiliser la méthode deepEquals() pour une comparaison approfondie, ce qui est utile si nous avons des tableaux à deux dimensions.

Utilisez la méthode Arrays.deepEquals() pour comparer les tableaux en Java

Exemple de code :

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");
  }
}

Production:

Both arrays are the same

La méthode deepEquals() fonctionne bien pour une comparaison approfondie. La méthode Arrays.deepEquals() vérifie si deux tableaux sont égaux ou non.

Ces deux tableaux peuvent être à une, deux ou même plusieurs dimensions.

Comment cette méthode décide-t-elle si les tableaux fournis sont égaux ou non ? Pour cela, vous devez avoir les points suivants à l’esprit :

• Si les références des deux tableaux fournis sont nulles, les tableaux seraient profondément égaux.
• Nous pouvons déclarer deux références de tableau profondément égales si elles pointent vers les tableaux contenant le nombre exact d’éléments et les paires d’éléments correspondants.
• Deux éléments, element1 et element2 qui sont éventuellement nuls, seraient profondément égaux si l’une des conditions de la liste suivante était vérifiée :
  • Le Arrays.deepEquals(element1, element2) renvoie vrai si le type des deux tableaux est une référence d’objet.
  • Le Tableaux.equals(element1, element2) renvoie vrai si les deux tableaux sont du type primitif exact.
  • element1 == element2
  • element1.equals(element2) renvoie vrai.

Utiliser la boucle for pour comparer des tableaux en Java

Exemple de code :

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");
  }
}

Production:

Both arrays are the same

Ici, nous écrivons une fonction compare() qui prend deux tableaux au type int. Il les compare au niveau de l’élément individuel à l’aide de la boucle for et renvoie true si les deux tableaux sont identiques ; sinon, faux.