En Java, nous pouvons comparer deux tableaux en comparant chaque élément du tableau. Java Tableaux La classe fournit deux méthodes prédéfinies utilisées pour comparer deux tableaux en Java .
Dans cette section, nous apprendrons comment comparer deux tableaux en utilisant Tableaux.equals() méthode et Arrays.deepEquals() méthode. Parallèlement à cela, nous apprendrons également comment effectuer une comparaison approfondie entre les deux tableaux avec des exemples appropriés.
Deux tableaux sont égaux si :
- Ils sont du même type.
- Ils ont un nombre égal d'éléments.
- Les paires d'éléments correspondantes dans les deux tableaux doivent être égales.
- L'ordre des éléments doit être le même.
- Deux références de tableau sont égales si elles sont nulles.
Avant de passer au sujet, considérons d’abord l’exemple suivant et devinez le résultat.
ArrayEqualsExample1.java
qu'est-ce qu'une interface
public class ArrayEqualsExample1 { public static void main (String[] args) { //defining arrays to be compare int[] a1 = new int[] {1, 2, 3, 4, 5, 6, 7, 8}; int[] a2 = new int[] {1, 2, 3, 4, 5, 6, 7, 8}; //comparing references using == operator //works the same as a1.equals(a2) if (a1 == a2) System.out.println('Arrays are equal.'); else System.out.println('Arrays are not equal.'); } } Sortir:
Arrays are not equal.
Dans l'exemple ci-dessus, a1 et a2 sont les deux références de deux objets différents. Lorsque nous comparons deux variables de référence, nous obtenons le résultat Les tableaux ne sont pas égaux, tandis que les deux tableaux sont de même longueur et ont les mêmes éléments. Nous n'obtenons pas le résultat souhaité car l'opérateur égal (==) les compare en tant qu'objet.
Maintenant, nous n'avons qu'une option pour comparer deux tableaux, c'est-à-dire comparer le contenu (éléments) du tableau . Voyons comment comparer le contenu d'un tableau.
Ce serait bien si l'on comparait les éléments un par un. Pour comparer le contenu du tableau Java Tableaux La classe fournit les deux méthodes suivantes pour comparer deux tableaux :
tableau.de Java
- Méthode égale()
- Méthode deepEquals()
Méthode Arrays.equals()
Java Tableaux la classe fournit le équivaut à() méthode pour comparer deux tableaux. Il parcourt chaque valeur d'un tableau et compare les éléments à l'aide de la méthode equals().
Syntaxe:
si-sinon java
public static boolean equals(int[] a1, int[] a2)
Il analyse deux tableaux a1 et a2 à comparer. La méthode renvoie vrai si les tableaux sont égaux, sinon renvoie faux. Le Classe de tableaux a une liste de méthodes equals() surchargées pour différents types primitifs et une pour un type Object.
Remarque : lorsque vous utilisez le tableau d'objets, n'oubliez pas de remplacer la méthode equals(). Sinon, nous obtiendrons le résultat renvoyé par la méthode equals() de la classe Object.
ArrayEqualsExample2.java
import java.util.Arrays; public class ArrayEqualsExample2 { public static void main (String[] args) { //defining array to compare int[] array1 = new int[] {'a', 'b', 'c', 'd', 'e'}; int[] array2 = new int[] {'a', 'b', 'c', 'd', 'e'}; //comparing two arrays using equals() method if (Arrays.equals(array1, array2)) System.out.println('Arrays are equal.'); else System.out.println('Arrays are not equal.'); } } Sortir:
Arrays are equal.
Voyons un autre exemple.
ArrayEqualsExample3.java
if else, instructions java
import java.util.Arrays; public class ArrayEqualsExample3 { public static void main (String[] args) { //defining arrays to compare int[] array1 = new int [] {21, 32, 36, 47}; int[] array2 = new int [] {11, 22, 33, 44}; int[] array3 = new int [] {21, 32, 36, 47}; System.out.println('Are array1 and array2 equal?' + Arrays.equals(array1, array2)); System.out.println('Are array1 and array3 equal?' + Arrays.equals(array1, array3)); } } Sortir:
Are array1 and array2 equal? false Are array1 and array3 equal? true
On voit que le Tableaux.equals() La méthode compare les éléments du tableau. Ici, une question se pose : que se passe-t-il si un tableau a un tableau imbriqué ou d'autres références qui font référence à un objet différent mais ont les mêmes valeurs.
Comprenons-le à travers l'exemple suivant.
ArrayEqualsExample4.java
import java.util.Arrays; public class ArrayEqualsExample4 { public static void main (String[] args) { //defining array to compare String[] inarray1 = new String[] {'mango', 'grapes', 'plum', 'watermelon', 'apple'}; String[] inarray2 = new String[] {'mango', 'grapes', 'plum', 'watermelon', 'apple'}; Object[] array1 = {inarray1}; // array1 have only one element Object[] array2 = {inarray2}; // array2 also have only one element //comparing two arrays using equals() method if (Arrays.equals(array1, array2)) System.out.println('Arrays are equal.'); else System.out.println('Arrays are not equal.'); } } Sortir:
Arrays are not equal.
Dans l’exemple ci-dessus, nous voyons que la méthode equals() n’est pas capable d’effectuer une comparaison approfondie. Pour résoudre ce problème, la classe Java Arrays fournit une autre méthode deepEquals() qui compare en profondeur les deux tableaux.
Méthode Arrays.deepEquals()
Java Tableaux la classe fournit une autre méthode profondEquals() pour comparer en profondeur le tableau. Ici, comparer en profondeur signifie qu'il peut comparer deux tableaux imbriqués de profondeur arbitraire. Deux références d'objet tableaux e1 et e2 sont profondément égales s'ils remplissent l'une des conditions suivantes :
- e1=e2
- égal(e2) renvoie vrai.
- Si e1 et e2 sont tous deux du même type primitif, la surcharge de la méthode Arrays.equals(e1, e2) renvoie true.
- Si e1 et e2 sont tous deux des tableaux de types de référence d’objet, la méthode Arrays.deepEquals(e1, e2) renvoie true.
Syntaxe:
public static boolean deepEquals(Object[] a1, Object[] a2)
La méthode analyse les deux tableaux a1 et a2 à comparer. Il renvoie vrai si les deux tableaux sont profondément égaux, sinon renvoie faux.
listes CSS
Créons un programme et comparons en profondeur deux tableaux en utilisant le profondEquals() méthode de la classe Arrays.
ArrayEqualsExample5.java
import java.util.Arrays; public class ArrayEqualsExample5 { public static void main (String[] args) { //defining array to compare String[] inarray1 = new String[] {'mango', 'grapes', 'plum', 'watermelon', 'apple'}; String[] inarray2 = new String[] {'mango', 'grapes', 'plum', 'watermelon', 'apple'}; Object[] array1 = {inarray1}; // array1 have only one element Object[] array2 = {inarray2}; // array2 also have only one element //comparing two arrays using equals() method if (Arrays.deepEquals(array1, array2)) System.out.println('Arrays are equal.'); else System.out.println('Arrays are not equal.'); } } Sortir:
Arrays are equal.