streamalism.org

1. Oversigt

I denne vejledning dykker vi ned i detaljerne i deepEquals metode fra Arrays klasse. Vi ser, hvornår vi skal bruge denne metode, og vi gennemgår nogle enkle eksempler.

For at lære mere om de forskellige metoder i java.util.Arrays klasse, se vores hurtige guide.

2. Formål

Vi skulle brug deepEquals metode, når vi vil kontrollere ligheden mellem to indlejrede eller flerdimensionelle arrays. Når vi også vil sammenligne to arrays sammensat af brugerdefinerede objekter, som vi vil se senere, skal vi tilsidesætte lige med metode.

Lad os nu finde ud af flere detaljer om deepEquals metode.

2.1. Syntaks

Vi starter med at se på metodesignatur:

offentlige statiske boolske deepEquals (Object [] a1, Object [] a2)

Fra metodesignaturen bemærker vi det vi kan ikke bruge deepEquals at sammenligne to ensdimensionelle arrays af primitive datatyper. Til dette skal vi enten indpakke det primitive array til dets tilsvarende indpakning eller bruge Arrays. Ligestilling metode, som har overbelastede metoder til primitive arrays.

2.2. Implementering

Ved at analysere metodens interne implementering kan vi se det metoden kontrollerer ikke kun elementernes øverste niveau, men kontrollerer også rekursivt alle underelementer af den.

Derfor skal vi undgå at bruge deepEquals metode med arrays, der har en selvreference fordi dette vil resultere i en java.lang.StackOverflowError.

Lad os derefter finde ud af, hvilket output vi kan få fra denne metode.

3. Output

Det Arrays.deepEquals metode returnerer:

• rigtigt hvis begge parametre er det samme objekt (har samme reference)
• rigtigt hvis begge parametre er nul
• falsk hvis kun en af ​​de to parametre er nul
• falsk hvis arraysne har forskellige længder
• rigtigt hvis begge arrays er tomme
• rigtigt hvis arrays indeholder det samme antal elementer, og hvert par underelementer er dybt ens
• falsk i andre tilfælde

I det næste afsnit vil vi se på nogle kodeeksempler.

4. Eksempler

Nu er det tid til at begynde at se på deepEquals metode i aktion. Desuden sammenligner vi deepEquals metode med lige med metode fra det samme Arrays klasse.

4.1. Ensidige arrays

Lad os først starte med et simpelt eksempel og sammenligne to ensdimensionelle arrays af typen Objekt:

 Objekt [] anArray = nyt objekt [] {"string1", "string2", "string3"}; Objekt [] anotherArray = nyt objekt [] {"string1", "string2", "string3"}; assertTrue (Arrays.equals (anArray, anotherArray)); assertTrue (Arrays.deepEquals (anArray, anotherArray));

Vi ser det begge lige med og deepEquals metoder vender tilbage rigtigt. Lad os finde ud af, hvad der sker, hvis et element i vores arrays er nul:

 Objekt [] anArray = nyt objekt [] {"string1", null, "string3"}; Objekt [] anotherArray = nyt objekt [] {"string1", null, "string3"}; assertTrue (Arrays.equals (anArray, anotherArray)); assertTrue (Arrays.deepEquals (anArray, anotherArray));

Vi ser, at begge påstande passerer. Derfor kan vi konkludere, at når du bruger deepEquals metode, nul værdier accepteres i enhver dybde i inputarrayerne.

Men lad os prøve en ting mere, og lad os kontrollere opførslen med indlejrede arrays:

 Objekt [] anArray = nyt objekt [] {"streng1", null, ny streng [] {"nestedString1", "nestedString2"}}; Objekt [] anotherArray = nyt objekt [] {"streng1", null, ny streng [] {"nestedString1", "nestedString2"}}; assertFalse (Arrays.equals (anArray, anotherArray)); assertTrue (Arrays.deepEquals (anArray, anotherArray));

Her finder vi ud af, at deepEquals vender tilbage rigtigt mens lige med vender tilbage falsk. Dette er fordi deepEquals kalder sig rekursivt, når man støder på en matrix, mens ligesammenligning bare sammenligner referencerne for underarrangementer.

4.2. Flerdimensionelle arrays af primitive typer

Lad os derefter kontrollere adfærd ved hjælp af flerdimensionelle arrays. I det næste eksempel har de to metoder forskellige output og understreger det faktum, at vi skal bruge deepEquals i stedet for lige med metode, når vi sammenligner flerdimensionelle arrays:

 int [] [] anArray = {{1, 2, 3}, {4, 5, 6, 9}, {7}}; int [] [] anotherArray = {{1, 2, 3}, {4, 5, 6, 9}, {7}}; assertFalse (Arrays.quals (anArray, anotherArray)); assertTrue (Arrays.deepEquals (anArray, anotherArray));

4.3. Flerdimensionelle arrays af brugerdefinerede objekter

Lad os endelig kontrollere adfærden for deepEquals og lige med metoder til afprøvning af lighed med to flerdimensionelle arrays for et brugerdefineret objekt:

Lad os starte med at oprette en simpel Person klasse:

 klasse Person {privat int id; privat strengnavn; privat int alder // constructor & getters & setters @Override public boolean equals (Object obj) {if (this == obj) {return true; } hvis (obj == null) {return false; } hvis (! (obj instans af person)) returnerer falsk; Person person = (Person) obj; return id == person.id && name.equals (person.name) && age == person.age; }}

Det er nødvendigt at tilsidesætte lige med metode for vores Person klasse. Ellers er standardindstillingen lige med metode sammenligner kun referencerne for objekterne.

Lad os også tage i betragtning, at selvom det ikke er relevant for vores eksempel, skal vi altid tilsidesætte hashCode når vi tilsidesætter lige med metode, så vi ikke overtræder deres kontrakter.

Dernæst kan vi sammenligne to flerdimensionelle arrays af Person klasse:

 Person personArray1 [] [] = {{ny person (1, "John", 22), ny person (2, "Mike", 23)}, {ny person (3, "Steve", 27), ny person ( 4, "Gary", 28)}}; Person personArray2 [] [] = {{ny person (1, "John", 22), ny person (2, "Mike", 23)}, {ny person (3, "Steve", 27), ny person ( 4, "Gary", 28)}}; assertFalse (Arrays.equals (personArray1, personArray2)); assertTrue (Arrays.deepEquals (personArray1, personArray2));

Som et resultat af rekursiv sammenligning af underelementerne har de to metoder igen forskellige resultater.

Endelig er det værd at nævne, atObjects.deepEquals metoden udfører Arrays.deepEquals metode internt når det kaldes med to Objekt arrays:

 assertTrue (Objects.deepEquals (personArray1, personArray2));

5. Konklusion

I denne hurtige vejledning lærte vi, at vi skulle bruge Arrays.deepEquals metode, når vi vil sammenligne ligestilling mellem to indlejrede eller flerdimensionelle opstillinger af objekter eller primitive typer.

Som altid er artiklens fulde kildekode tilgængelig på GitHub.