A Java, podem comparar dues matrius comparant cada element de la matriu. Java Arrays class proporciona dos mètodes predefinits que s'utilitzen per compareu dues matrius a Java .
En aquest apartat aprendrem com comparar dues matrius utilitzant Arrays.equals() mètode i Arrays.deepEquals() mètode. Juntament amb això, també aprendrem com realitzar una comparació profunda entre les dues matrius amb exemples adequats.
Dues matrius són iguals si:
- Són del mateix tipus.
- Tenen el mateix nombre d'elements.
- Els parells d'elements corresponents en ambdues matrius han de ser iguals.
- L'ordre dels elements ha de ser el mateix.
- Dues referències de matriu són iguals si són nul·les.
Abans de passar al tema, primer, considereu l'exemple següent i endevineu la sortida.
ArrayEqualsExample1.java
sumador ple
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.'); } } Sortida:
Arrays are not equal.
A l'exemple anterior, a1 i a2 són les dues referències de dos objectes diferents. Quan comparem dues variables de referència, obtenim la sortida Les matrius no són iguals, mentre que ambdues matrius tenen la mateixa longitud i tenen els mateixos elements. No obtenim la sortida desitjada perquè l'operador equals (==) les compara com a objecte.
Ara, només tenim una opció per comparar dues matrius, és a dir. compareu el contingut (elements) de la matriu . Vegem com comparar el contingut de la matriu.
Serà bo si comparem els elements un per un. Per comparar el contingut de la matriu Java Arrays class proporciona els dos mètodes següents per comparar dues matrius:
q1 q2 q3 q4
- Mètode equals().
- Mètode deepEquals().
Arrays.equals() Mètode
Java Arrays classe proporciona el és igual() mètode per comparar dues matrius. Itera sobre cada valor d'una matriu i compara els elements mitjançant el mètode equals().
Sintaxi:
public static boolean equals(int[] a1, int[] a2)
Analitza dues matrius a1 i a2 que s'han de comparar. El mètode retorna true si les matrius són iguals, en cas contrari retorna fals. El Classe de matrius té una llista de mètodes equals() sobrecarregats per a diferents tipus primitius i un per a un tipus d'objecte.
Nota: mentre utilitzeu la matriu d'objectes, no us oblideu d'anul·lar el mètode equals(). En cas contrari, obtindrem la sortida que retorna el mètode 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.'); } } Sortida:
Arrays are equal.
Vegem un altre exemple.
bin a bcd
ArrayEqualsExample3.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)); } } Sortida:
Are array1 and array2 equal? false Are array1 and array3 equal? true
Veiem que el Arrays.equals() El mètode compara els elements de la matriu. Aquí, sorgeix la pregunta de què passa si una matriu té una matriu imbricada o algunes altres referències que fan referència a un objecte diferent però que tenen els mateixos valors.
Entenem-ho a través del següent exemple.
ArrayEqualsExample4.java
diferència entre un gigabyte i un megabyte
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.'); } } Sortida:
Arrays are not equal.
A l'exemple anterior, veiem que el mètode equals() no és capaç de realitzar una comparació profunda. Per resoldre aquest problema, la classe Java Arrays proporciona un altre mètode deepEquals() que compara profundament les dues matrius.
Arrays.deepEquals() Mètode
Java Arrays classe proporciona un altre mètode deepEquals() per comparar profundament la matriu. Aquí, comparar profundament significa que pot comparar dues matrius imbricades de profunditat arbitrària. Dues matrius de referència d'objectes e1 i e2 són profundament iguals si compleixen alguna de les condicions següents:
- e1=e2
- equals(e2) retorna cert.
- Si e1 i e2 són tots dos del mateix tipus primitiu, la sobrecàrrega del mètode Arrays.equals(e1, e2) retorna true.
- Si e1 i e2 són matrius de tipus de referència d'objectes, el mètode Arrays.deepEquals(e1, e2) retorna true.
Sintaxi:
processament paral·lel
public static boolean deepEquals(Object[] a1, Object[] a2)
El mètode analitza les dues matrius a1 i a2 que s'han de comparar. Retorna true si ambdues matrius són profundament iguals, en cas contrari retorna false.
Creem un programa i comparem profundament dues matrius utilitzant el deepEquals() mètode 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.'); } } Sortida:
Arrays are equal.