Sammenligning af arrays i Java
1. Oversigt
I denne vejledning skal vi se på forskellige måder at sammenligne arrays i Java på. Vi dækker konventionelle metoder, og vi vil også se nogle eksempler ved hjælp af lambdaudtryk.
2. Sammenligning af arrays
Vi sammenligner arrays i Java, og som vi ved, er disse objekter. Lad os derfor opdatere nogle grundlæggende begreber:
- Objekter har referencer og værdier
- To lige referencer skal pege på den samme værdi
- To forskellige værdier skal have forskellige referencer
- To lige værdier har ikke nødvendigvis de samme referencer
- Primitive værdier sammenlignes kun pr. Værdi
- Strengbogstaver sammenlignes kun pr. Værdi
2.1. Sammenligning af objektreferencer
Hvis vi har to referencer, der peger på den samme matrix, skal vi altid få et resultat rigtigt i en lig sammenligning med == operatør.
Lad os se på et eksempel:
Streng [] plan1 = ny streng [] {"A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332"}; Streng [] plan2 = plan1;Først oprettede vi en række planmodeller, der er refereret til fly1. Vi skaber derefter fly2, hvilke referencer fly1. Ved at gøre dette er vi oprettelse af to referencertil det samme array i hukommelsen. Derfor er den “Fly1 == fly2” udtryk vender tilbage rigtigt.
For arrays er lige med() metoden er den samme som == operatoren. Så, plan1.equals (planes2) vender tilbage rigtigt fordi begge referencer henviser til det samme objekt. Generelt sagt, array1.eqauls (array2) kommer tilbage rigtigt hvis og kun hvis udtrykket “array1 == array2 ″ vender tilbage rigtigt.
Lad os hævde, om de to referencer er ens:
assertThat (plan1) .isSameAs (planes2);Lad os nu være sikre på, at de værdier, der henvises til fly1 er faktisk de samme som dem, der henvises til fly2. Derfor kan vi ændre det array, der refereres til fly2, og kontroller, om ændringerne har nogen indvirkning på det array, der er refereret til fly1:
planes2 [0] = "747";For endelig at se dette arbejde, lad os komme med vores påstande:
assertThat (planer1) .isSameAs (planer2); assertThat (plan2 [0]). er EqualTo ("747"); assertThat (plan1 [0]). er EqualTo ("747");Med denne enhedstest var vi i stand til at sammenligne to arrays med reference.
Vi har dog kun bevist det en reference, når den er tildelt værdien af en anden, vil henvise til den samme værdi.
Vi opretter nu to forskellige arrays med de samme værdier:
Streng [] plan1 = ny streng [] {"A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332"}; Streng [] plan2 = ny streng [] {"A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332"};Da de er forskellige objekter, ved vi med sikkerhed, at de ikke er de samme. Vi kan derfor sammenligne dem:
assertThat (plan1) .isNotSameAs (plan2);For at opsummere har vi i dette tilfælde to arrays i hukommelsen, der indeholder det samme Snor værdier i nøjagtig samme rækkefølge. Imidlertid er ikke kun de refererede arrays forskellige i indhold, men selve referencerne er også forskellige.
2.2. Sammenligning af array længder
Arrangementernes længde kan sammenlignes uanset af deres elementtyper, eller om deres værdier er udfyldt eller ej.
Lad os oprette to arrays:
endelig streng [] plan1 = ny streng [] {"A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332"}; sidste Heltal [] mængder = nyt Heltal [] {10, 12, 34, 45, 12, 43, 5, 2};Dette er to forskellige arrays med forskellige elementtyper. I dette datasæt registrerer vi som et eksempel, hvor mange fly af hver model der er lagret på lageret. Lad os nu køre enhedstest på dem:
assertThat (plan1) .hasSize (8); hævder, at (mængder) .har størrelse (8);Med dette har vi bevist, at begge arrays har otte elementer, og at længde egenskab returnerer det korrekte antal elementer for hver matrix.
2.3. Sammenligning af arrays med Arrays. Ligestilling
Indtil videre sammenlignede vi kun arrays baseret på deres objektidentiteter. På den anden side, For at kontrollere, om to arrays er ens med hensyn til deres indhold, leverer Java Arrays. Ligestilling statisk metode. Denne metode gentages gennem arrays, per position parallelt og anvender == operatoren,for hvert par elementer.
Lad os oprette to forskellige arrays med det samme Snor bogstaver i nøjagtig samme rækkefølge:
Streng [] plan1 = ny streng [] {"A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332"}; Streng [] plan2 = ny streng [] {"A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332"};Og nu, lad os hævde, at de er lige:
assertThat (Arrays.quals (plan1, plan2)). isTrue ();Hvis vi ændrer rækkefølgen af værdierne i det andet array:
Streng [] plan1 = ny streng [] {"A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332"}; Streng [] plan2 = ny streng [] {"B738", "A320", "A321", "A319", "B77W", "B737", "A333", "A332"}; Vi får et andet resultat:
assertThat (Arrays.quals (plan1, plan2)). er Falsk ();2.4. Sammenligning af arrays med Arrays.deepEquals
Bruger == operatør er let, hvis vi bruger enkle typer i Java. Disse kunne være primitive typer eller Snor bogstaver. En sammenligning mellem arrays af Objekts kan være mere kompliceret. Årsagen bag dette forklares fuldt ud i vores Arrays.deepEquals artikel. Lad os se et eksempel.
Lad os først starte med en Fly klasse:
public class Plane {private final String name; privat endelig String model; // getters og setters}Og lad os implementere hashCode og lige med metoder:
@Override offentlige boolske er lig med (Objekt o) hvis (dette == o) returnerer sandt; hvis (o == null @ Override public int hashCode () {return Objects.hash (navn, model);}For det andet, lad os oprette følgende to-element arrays:
Fly [] [] plan1 = nyt plan [] [] {nyt fly [] {nyt fly ("fly 1", "A320")}, nyt fly [] {nyt fly ("fly 2", "B738") }}; Fly [] [] plan2 = nyt plan [] [] {nyt fly [] {nyt fly ("fly 1", "A320")}, nyt fly [] {nyt fly ("fly 2", "B738") }}; Lad os nu se, om de er sande, dybt lige arrays:
assertThat (Arrays.deepEquals (plan1, plan2)). isTrue ();For at sikre, at vores sammenligning fungerer som forventet, lad os nu ændre rækkefølgen på vores sidste matrix:
Fly [] [] plan1 = nyt plan [] [] {nyt fly [] {nyt fly ("fly 1", "A320")}, nyt fly [] {nyt fly ("fly 2", "B738") }}; Fly [] [] plan2 = nyt plan [] [] {nyt fly [] {nyt fly ("plan 2", "B738")}, nyt plan [] {nyt fly ("fly 1", "A320") }};Lad os endelig teste, om de faktisk ikke er lige længere:
assertThat (Arrays.deepEquals (plan1, plan2)). er Falsk ();2.5. Sammenligning af arrays med forskellige ordrer af elementer
For at kontrollere, om arrays er ens, uanset rækkefølgen af elementer, skal vi definere hvad der gør en instans af vores Fly enestående. For vores sag er et andet navn eller en model nok til at bestemme, at et plan er forskelligt fra et andet. Vi har etableret dette ved allerede at have implementeret begge dele hashCode og lige med metoder. Dette indebærer, at før vi kan sammenligne vores arrays, skal vi sortere dem. Til det har vi brug for en Komparator:
Comparator planeComparator = (o1, o2) -> {if (o1.getName (). Er lig med (o2.getName ())) {return o2.getModel (). ComparTo (o1.getModel ()); } returner o2.getName (). sammenlignTo (o1.getName ()); };Heri Komparator, vi prioriterer navnet. Hvis navnene er ens, løser vi tvetydigheden ved at se på modellen. Vi sammenligner strenge ved hjælp af sammenligne med metode af typen Snor.
Vi vil være i stand til at finde ud af, om arrays er ens uanset sorteringsrækkefølgen. For at gøre det, lad os nu sortere vores arrays:
Arrays.sort (plan1 [0], planeComparator); Arrays.sort (plan2 [0], planeComparator);Og endelig, lad os teste dem:
assertThat (Arrays.deepEquals (plan1, plan2)). isTrue ();Efter at have sorteret arrays i samme rækkefølge først tillader vi deepEquals metode til at finde ud af, om disse to arrays er ens.
3. Konklusion
I denne vejledning har vi set forskellige måder at sammenligne arrays på. For det andet så vi forskellen mellem at sammenligne referencer og værdier. Derudover har vi taget et kig på, hvordan vi kan sammenligne arrays dybt. Endelig så vi forskellen mellem en normal sammenligning og en dyb sammenligning ved hjælp af lige med og deepEquals, henholdsvis.
Som altid er den fulde kildekode til eksemplerne tilgængelig på GitHub.
