Op Java kunnen we dat wel vergelijk twee arrays door elk element van de array te vergelijken. Java Arrays class biedt twee vooraf gedefinieerde methoden die worden gebruikt vergelijk twee arrays in Java .
In dit gedeelte zullen we leren hoe twee arrays te vergelijken gebruik makend van Arrays.is gelijk aan() methode en Arrays.deepEquals() methode. Daarnaast zullen we ook leren hoe u een diepgaande vergelijking tussen de twee arrays kunt uitvoeren met de juiste voorbeelden.
Twee arrays zijn gelijk als:
- Ze zijn van hetzelfde type.
- Ze hebben een gelijk aantal elementen.
- Overeenkomstige paren elementen in beide arrays moeten gelijk zijn.
- De volgorde van de elementen moet hetzelfde zijn.
- Twee arrayreferenties zijn gelijk als ze nul zijn.
Voordat u naar het onderwerp gaat, moet u eerst het volgende voorbeeld overwegen en de uitvoer raden.
ArrayEqualsExample1.java
kaart java-iterator
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.'); } } Uitgang:
Arrays are not equal.
In het bovenstaande voorbeeld zijn a1 en a2 de twee referenties van twee verschillende objecten. Wanneer we twee referentievariabelen vergelijken, krijgen we de uitvoer Arrays zijn niet gelijk, terwijl beide arrays even lang zijn en dezelfde elementen hebben. We krijgen niet de gewenste uitvoer omdat de operator gelijk aan (==) ze als een object vergelijkt.
Nu hebben we alleen een optie om twee arrays te vergelijken, d.w.z. vergelijk de inhoud (elementen) van de array . Laten we eens kijken hoe we de array-inhoud kunnen vergelijken.
Het zou goed zijn als we de elementen één voor één vergelijken. Om de inhoud van de array Java te vergelijken Arrays class biedt de volgende twee methoden om twee arrays te vergelijken:
arp een opdracht
- is gelijk aan() Methode
- deepEquals()-methode
Arrays.equals()-methode
Java Arrays klasse biedt de is gelijk aan() methode om twee arrays te vergelijken. Het herhaalt elke waarde van een array en vergelijkt de elementen met behulp van de equals() -methode.
Syntaxis:
public static boolean equals(int[] a1, int[] a2)
Het ontleedt twee arrays a1 en a2 die moeten worden vergeleken. De methode retourneert waar als de arrays gelijk zijn, en retourneert anders false. De Arrays-klasse heeft een lijst met overbelaste equals()-methoden voor verschillende primitieve typen en één voor een objecttype.
Opmerking: Vergeet bij het gebruik van de array met objecten niet de methode equals() te overschrijven. Anders krijgen we de uitvoer die wordt geretourneerd door de equals() -methode van de Object-klasse.
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.'); } } Uitgang:
math.pow java
Arrays are equal.
Laten we nog een voorbeeld bekijken.
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)); } } Uitgang:
Are array1 and array2 equal? false Are array1 and array3 equal? true
Wij zien dat de Arrays.is gelijk aan() methode vergelijkt de elementen van de array. Hier rijst de vraag wat er moet gebeuren als een array een geneste array of andere referenties heeft die naar een ander object verwijzen maar dezelfde waarden hebben.
Laten we het begrijpen aan de hand van het volgende voorbeeld.
Java-schijfje
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.'); } } Uitgang:
Arrays are not equal.
In het bovenstaande voorbeeld zien we dat de equals() methode geen diepgaande vergelijking kan uitvoeren. Om dit probleem op te lossen, biedt de klasse Java Arrays een andere methode deepEquals() die de twee arrays diepgaand vergelijkt.
Arrays.deepEquals()-methode
Java Arrays klasse biedt een andere methode deepEquals() om de array diepgaand te vergelijken. Diep vergelijken betekent hier dat het twee geneste arrays van willekeurige diepte kan vergelijken. Twee arrays-objectreferentie e1 en e2 zijn diep gelijk als ze aan een van de volgende voorwaarden voldoen:
sorteer arraylijst java
- e1=e2
- is gelijk aan(e2) retourneert waar.
- Als e1 en e2 beide van hetzelfde primitieve type zijn, retourneert de overbelasting van de methode Arrays.equals(e1, e2) waar.
- Als e1 en e2 beide arrays van objectreferentietypen zijn, retourneert de methode Arrays.deepEquals(e1, e2) true.
Syntaxis:
public static boolean deepEquals(Object[] a1, Object[] a2)
De methode ontleedt de twee arrays a1 en a2 om te vergelijken. Het retourneert waar als beide arrays zeer gelijk zijn, anders wordt onwaar geretourneerd.
Laten we een programma maken en twee arrays diepgaand vergelijken met behulp van de deepEquals() methode van de klasse 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.'); } } Uitgang:
Arrays are equal.