I Java kan vi jämför två arrayer genom att jämföra varje element i arrayen. Java Matriser klass tillhandahåller två fördefinierade metoder som används för att jämför två arrayer i Java .
I det här avsnittet kommer vi att lära oss hur man jämför två arrayer använder sig av Arrays.equals() metod och Arrays.deepEquals() metod. Tillsammans med detta kommer vi också att lära oss hur man utför en djup jämförelse mellan de två arrayerna med ordentliga exempel.
Två arrayer är lika om:
- De är av samma typ.
- De har lika många element.
- Motsvarande par av element i båda arrayerna måste vara lika.
- Ordningen på element måste vara densamma.
- Två arrayreferenser är lika om de är noll.
Innan du går till ämnet, överväg först följande exempel och gissa resultatet.
ArrayEqualsExample1.java
ordomslutning css
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.'); } } Produktion:
Arrays are not equal.
I exemplet ovan är a1 och a2 de två referenserna till två olika objekt. När vi jämför två referensvariabler får vi utdata Arrayer är inte lika, medan båda arrayerna är lika långa och har samma element. Vi får inte det önskade resultatet eftersom operatorn lika (==) jämför dem som ett objekt.
Nu har vi bara ett alternativ att jämföra två arrayer, dvs. jämför innehållet (elementen) i arrayen . Låt oss se hur man jämför arrayinnehåll.
Det blir bra om vi jämför elementen en efter en. För att jämföra innehållet i arrayen Java Matriser klass tillhandahåller följande två metoder för att jämföra två arrayer:
char till sträng
- equals() Metod
- deepEquals() metod
Arrays.equals() Metod
Java Matriser klass ger lika() metod för att jämföra två arrayer. Den itererar över varje värde i en array och jämför elementen med metoden equals().
Syntax:
public static boolean equals(int[] a1, int[] a2)
Den analyserar två arrayer a1 och a2 som ska jämföras. Metoden returnerar true om arrayer är lika, annars returnerar false. De Arrays klass har en lista över överbelastade equals()-metoden för olika primitiva typer och en för en objekttyp.
Obs: Glöm inte att åsidosätta metoden equals() när du använder objektsuppsättningen. Annars kommer vi att få resultatet returnerat av metoden equals() för klassen 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.'); } } Produktion:
huffman kodningskod
Arrays are equal.
Låt oss se ett annat exempel.
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)); } } Produktion:
Are array1 and array2 equal? false Are array1 and array3 equal? true
Vi ser att Arrays.equals() metoden jämför elementen i arrayen. Här uppstår en fråga om att vad händer om en array har kapslad array eller några andra referenser som refererar till olika objekt men har samma värden.
Låt oss förstå det genom följande exempel.
vad är f5 på tangentbordet
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.'); } } Produktion:
Arrays are not equal.
I exemplet ovan ser vi att metoden equals() inte kan utföra en djup jämförelse. För att lösa detta problem tillhandahåller Java Arrays-klassen en annan metod deepEquals() som djupt jämför de två arrayerna.
Arrays.deepEquals() metod
Java Matriser klass tillhandahåller en annan metod deepEquals() för att djupt jämföra arrayen. Här betyder djupjämförelse att den kan jämföra två kapslade arrayer med godtyckligt djup. Två arrayer objektreferens e1 och e2 är djupt lika om de har något av följande villkor:
konvertera byte array till sträng
- e1=e2
- lika med(e2) returnerar sant.
- Om e1 och e2 båda är samma primitiva typ, returnerar överbelastningen av metoden Arrays.equals(e1, e2) sant.
- Om e1 och e2 båda är arrayer av objektreferenstyper, returnerar metoden Arrays.deepEquals(e1, e2) true.
Syntax:
public static boolean deepEquals(Object[] a1, Object[] a2)
Metoden analyserar de två arrayerna a1 och a2 som ska jämföras. Det returnerar sant om båda arrayerna är djupt lika, annars returnerar falskt.
Låt oss skapa ett program och djupt jämföra två arrayer med hjälp av deepEquals() metod för klassen 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.'); } } Produktion:
Arrays are equal.