streamalism.org

1. Oversikt

I denne veiledningen, vi skal utforske forskjellige måter å sammenligne to på HashMaps i Java.

Vi vil diskutere flere måter å sjekke om to HashMaps er like. Vi bruker også Java 8 Stream API og Guava for å få detaljerte forskjeller mellom forskjellige HashMaps.

2. Bruke Map.equals ()

Først skal vi bruke Map.equals () for å sjekke om to HashMaps har de samme oppføringene:

@Test offentlig ugyldig nårCompareTwoHashMapsUsingEquals_thenSuccess () {Map asiaCapital1 = new HashMap (); asiaCapital1.put ("Japan", "Tokyo"); asiaCapital1.put ("Sør-Korea", "Seoul"); Kart asiaCapital2 = nytt HashMap (); asiaCapital2.put ("Sør-Korea", "Seoul"); asiaCapital2.put ("Japan", "Tokyo"); Kart asiaCapital3 = nytt HashMap (); asiaCapital3.put ("Japan", "Tokyo"); asiaCapital3.put ("Kina", "Beijing"); assertTrue (asiaCapital1.equals (asiaCapital2)); assertFalske (asiaCapital1.equals (asiaCapital3)); }

Her lager vi tre HashMap objekter og legge til oppføringer. Så bruker vi Map.equals () for å sjekke om to HashMaps har de samme oppføringene.

Slik det Map.equals () fungerer er ved å sammenligne nøkler og verdier ved hjelp av Object.equals () metode. Dette betyr at det bare fungerer når både nøkkel- og verdiobjekter implementeres er lik() ordentlig.

For eksempel, Map.equals () fungerer ikke når verditypen er array, som en array's er lik() metoden sammenligner identitet og ikke innholdet i matrisen:

@Test offentlig ugyldig nårCompareTwoHashMapsWithArrayValuesUsingEquals_thenFail () {Map asiaCity1 = new HashMap (); asiaCity1.put ("Japan", ny streng [] {"Tokyo", "Osaka"}); asiaCity1.put ("Sør-Korea", ny streng [] {"Seoul", "Busan"}); Kart asiaCity2 = ny HashMap (); asiaCity2.put ("Sør-Korea", ny streng [] {"Seoul", "Busan"}); asiaCity2.put ("Japan", ny streng [] {"Tokyo", "Osaka"}); assertFalse (asiaCity1.equals (asiaCity2)); }

3. Bruke Java Strøm API

Vi kan også implementere vår egen metode for å sammenligne HashMaps ved hjelp av Java 8 Strøm API:

private boolske areEqual (Map first, Map second) {if (first.size ()! = second.size ()) {return false; } returner first.entrySet (). stream () .allMatch (e -> e.getValue (). er lik (second.get (e.getKey ()))); }

For enkelhets skyld implementerte vi er like() metode som vi nå kan bruke til å sammenligne HashMap gjenstander:

@Test offentlig ugyldig nårCompareTwoHashMapsUsingStreamAPI_thenSuccess () {assertTrue (areEqual (asiaCapital1, asiaCapital2)); assertFalske (areEqual (asiaCapital1, asiaCapital3)); }

Men vi kan også tilpasse vår egen metode areEqualWithArrayValue () for å håndtere matriseverdier ved hjelp av Arrays.equals () for å sammenligne to matriser:

private boolske areEqualWithArrayValue (Map first, Map second) {if (first.size ()! = second.size ()) {return false; } returner first.entrySet (). stream () .allMatch (e -> Arrays.equals (e.getValue (), second.get (e.getKey ()))); }

I motsetning til Map.equals (), vil vår egen metode vellykket sammenligne HashMaps med matriseverdier:

@Test offentlig ugyldig nårCompareTwoHashMapsWithArrayValuesUsingStreamAPI_thenSuccess () {assertTrue (areEqualWithArrayValue (asiaCity1, asiaCity2)); assertFalse (areEqualWithArrayValue (asiaCity1, asiaCity3)); }

4. Sammenligning HashMap Nøkler og verdier

La oss deretter se hvordan vi kan sammenligne to HashMap tastene og deres tilsvarende verdier.

4.1. Sammenligning HashMap Nøkler

Først kan vi sjekke om to HashMaps har samme nøkler ved å bare sammenligne deres Tastesett ():

@Test offentlig ugyldig nårCompareTwoHashMapKeys_thenSuccess () {assertTrue (asiaCapital1.keySet (). Er lik (asiaCapital2.keySet ())); assertFalse (asiaCapital1.keySet (). er lik (asiaCapital3.keySet ())); }

4.2. Sammenligning HashMap Verdier

Deretter får vi se hvordan vi kan sammenligne HashMap verdier en etter en.

Vi implementerer en enkel metode for å sjekke hvilke nøkler som har samme verdi i begge HashMaps ved hjelp av Strøm API:

private Map areEqualKeyValues ​​(Map first, Map second) {return first.entrySet (). stream () .collect (Collectors.toMap (e -> e.getKey (), e -> e.getValue (). equals (second. få (e.getKey ())))); }

Vi kan nå bruke areEqualKeyValues ​​() å sammenligne to forskjellige HashMaps for å se i detalj hvilke nøkler som har samme verdi og hvilke som har forskjellige verdier:

@Test offentlig ugyldig nårCompareTwoHashMapKeyValuesUsingStreamAPI_thenSuccess () {Map asiaCapital3 = new HashMap (); asiaCapital3.put ("Japan", "Tokyo"); asiaCapital3.put ("Sør-Korea", "Seoul"); asiaCapital3.put ("Kina", "Beijing"); Kart asiaCapital4 = nytt HashMap (); asiaCapital4.put ("Sør-Korea", "Seoul"); asiaCapital4.put ("Japan", "Osaka"); asiaCapital4.put ("Kina", "Beijing"); Kartresultat = areEqualKeyValues ​​(asiaCapital3, asiaCapital4); assertEquals (3, result.size ()); assertThat (result, hasEntry ("Japan", false)); assertThat (resultat, hasEntry ("Sør-Korea", sant)); assertThat (resultat, hasEntry ("Kina", sant)); }

5. Kartforskjell ved bruk av Guava

Til slutt får vi se hvordan få en detaljert forskjell mellom to HashMaps ved hjelp av Guava Kart. Forskjell ().

Denne metoden returnerer a Kartforskjell objekt som har en rekke nyttige metoder for å analysere forskjellen mellom Kart. La oss ta en titt på noen av disse.

5.1. MapDifference.entriesDiffering ()

Først skal vi oppnå vanlige nøkler som har forskjellige verdier i hver HashMap ved hjelp av MapDifference.entriesDiffering ():

@Test offentlig ugyldig givenDifferentMaps_whenGetDiffUsingGuava_thenSuccess () {Map asia1 = new HashMap (); asia1.put ("Japan", "Tokyo"); asia1.put ("Sør-Korea", "Seoul"); asia1.put ("India", "New Delhi"); Kart asia2 = nytt HashMap (); asia2.put ("Japan", "Tokyo"); asia2.put ("Kina", "Beijing"); asia2.put ("India", "Delhi"); MapDifference diff = Maps.difference (asia1, asia2); Kart entriesDiffering = diff.entriesDiffering (); assertFalse (diff.areEqual ()); assertEquals (1, entriesDiffering.size ()); assertThat (entriesDiffering, hasKey ("India")); assertEquals ("New Delhi", entriesDiffering.get ("India"). leftValue ()); assertEquals ("Delhi", entriesDiffering.get ("India"). rightValue ()); }

De oppføringerDifferens () metoden returnerer en ny Kart som inneholder settet med vanlige nøkler og Verdiforskjell objekter som verdisett.

Hver Verdiforskjell objektet har en leftValue () og rightValue () metoder som returnerer verdiene i de to Karthenholdsvis.

5.2. MapDifference.entriesOnlyOnRight () og MapDifference.entriesOnlyOnLeft ()

Deretter kan vi få oppføringer som bare finnes i en HashMap ved hjelp av MapDifference.entriesOnlyOnRight () og MapDifference.entriesOnlyOnLeft ():

@Test public void givenDifferentMaps_whenGetEntriesOnOneSideUsingGuava_thenSuccess () {MapDifference diff = Maps.difference (asia1, asia2); KartoppføringerOnlyOnRight = diff.entriesOnlyOnRight (); KartoppføringerOnlyOnLeft = diff.entriesOnlyOnLeft (); assertEquals (1, entriesOnlyOnRight.size ()); assertEquals (1, entriesOnlyOnLeft.size ()); assertThat (entriesOnlyOnRight, hasEntry ("Kina", "Beijing")); assertThat (entriesOnlyOnLeft, hasEntry ("Sør-Korea", "Seoul")); }

5.3. MapDifference.entriesInCommon ()

Neste, vi får vanlige oppføringer ved hjelp av MapDifference.entriesInCommon ():

@Test public void givenDifferentMaps_whenGetCommonEntriesUsingGuava_thenSuccess () {MapDifference diff = Maps.difference (asia1, asia2); KartoppføringerInCommon = diff.entriesInCommon (); assertEquals (1, entriesInCommon.size ()); assertThat (entriesInCommon, hasEntry ("Japan", "Tokyo")); }

5.4. Tilpasse Kart. Forskjell () Oppførsel

Siden Kart. Forskjell () bruk er lik() og hashCode () som standard å sammenligne oppføringer, vil det ikke fungere for objekter som ikke implementerer dem ordentlig:

@Test offentlig ugyldighet givenSimilarMapsWithArrayValue_whenCompareUsingGuava_thenFail () {MapDifference diff = Maps.difference (asiaCity1, asiaCity2); assertFalse (diff.areEqual ()); }

Men, vi kan tilpasse metoden som brukes i sammenligning ved hjelp av Likestilling.

For eksempel vil vi definere Likestilling for type Streng [] å sammenligne Streng [] verdier i våre HashMaps som vi vil:

@Test offentlig ugyldighet givenSimilarMapsWithArrayValue_whenCompareUsingGuavaEquivalence_thenSuccess () {Equivalence eq = new Equivalence () {@ Override protected boolean doEquivalent (String [] a, String [] b) {return Arrays.equals (a, b); } @ Override-beskyttet int doHash (streng [] -verdi) {returverdi.hashCode (); }}; MapDifference diff = Maps.difference (asiaCity1, asiaCity2, eq); assertTrue (diff.areEqual ()); diff = Maps.difference (asiaCity1, asiaCity3, eq); assertFalse (diff.areEqual ()); }

6. Konklusjon

I denne artikkelen diskuterte vi forskjellige måter å sammenligne på HashMaps i Java. Vi lærte flere måter å sjekke om to HashMaps er like og hvordan du også får den detaljerte forskjellen.

Hele kildekoden er tilgjengelig på GitHub.