streamalism.org

1. Oversikt

I denne opplæringen vil vi utforske konseptet med en grunn vs dyp kopi av en HashMap sammen med flere teknikker for å kopiere en HashMap i Java.

Vi vil også vurdere noen av de eksterne bibliotekene som kan hjelpe oss i spesifikke tilfeller.

2. Grunn mot dype kopier

For det første, la oss forstå konseptet med grunne og dype kopier i HashMaps.

2.1. Grunn kopi

En grunne kopi av en HashMap er en ny HashMap med tilordninger til samme nøkkel- og verdiobjekter som originalen HashMap.

For eksempel vil vi lage en Ansatt klasse og deretter et kart med Ansatt forekomster som verdier:

offentlig klasse Ansatt {privat strengnavn; // constructor, getters and setters} 

HashMap-kart = nytt HashMap (); Medarbeider emp1 = ny ansatt ("John"); Medarbeider emp2 = ny ansatt ("Norman"); map.put ("emp1", emp1); map.put ("emp2", emp2); 

Nå skal vi bekrefte at det originale kartet og dets grunne kopi er forskjellige objekter:

HashMap shallowCopy = // implementering av grunne kopier assertThat (shallowCopy) .isNotSameAs (kart);

Fordi dette er en grunne kopi, hvis vi endrer en Ansatt egenskapens egenskaper, vil det påvirke både det originale kartet og dets grunne kopi:

emp1.setFirstName ("Johny"); assertThat (shallowCopy.get ("emp1")). isEqualTo (map.get ("emp1"));

2.2. Dyp kopi

En dyp kopi av en HashMap er en ny HashMap som kopierer dypt alle kartleggingen. Derfor oppretter den nye objekter for alle nøkler, verdier og tilordninger.

Her vil eksplisitt endring av tilordningene (nøkkelverdier) ikke påvirke den dype kopien:

HashMap deepCopy = // implementering av dyp kopi emp1.setFirstName ("Johny"); assertThat (deepCopy.get ("emp1")). isNotEqualTo (map.get ("emp1")); 

3. HashMap API

3.1. Bruker HashMapCinstruktør

HashMap’S parametriserte konstruktør HashMap (Kart m)gir en rask måte å grunne på hele kartet:

HashMap shallowCopy = ny HashMap (originalMap); 

3.2. Ved hjelp av Map.clone ()

I likhet med konstruktøren, HashMap#klone metoden skaper også en rask, grunne kopi:

HashMap shallowCopy = originalMap.clone (); 

3.3. Ved hjelp av Map.put ()

EN HashMap kan lett kopieres grunt ved å gjenta over hver oppføring og ringe sette() metode på et annet kart:

HashMap shallowCopy = ny HashMap (); Sett oppføringer = originalMap.entrySet (); for (Map.Entry mapEntry: entries) {shallowCopy.put (mapEntry.getKey (), mapEntry.getValue ()); } 

3.4. Ved hjelp av Map.putAll ()

I stedet for å gjenta gjennom alle oppføringene, kan vi bruke putt alle() metode, som grunne kopier alle kartlegginger i ett trinn:

HashMap shallowCopy = ny HashMap (); shallowCopy.putAll (originalMap); 

Vi bør merke oss det sette() og putt alle() erstatt verdiene hvis det er en matchende nøkkel.

Det er også interessant å merke seg at hvis vi ser på HashMap’S konstruktør, klone (), og putt alle() implementering, vil vi finne at alle bruker samme interne metode for å kopiere oppføringer - putMapEntries ().

4. Kopiering HashMapBruke Java 8 Strøm API

Vi kan bruke Java 8 Strøm API for å lage en grunne kopi av en HashMap:

Sett oppføringer = originalMap.entrySet (); HashMap shallowCopy = (HashMap) entries.stream () .collect (Collectors.toMap (Map.Entry :: getKey, Map.Entry :: getValue)); 

5. Google Guava

Ved hjelp av Guava Maps kan vi enkelt lage uforanderlige kart, sammen med det sorterte og bi-kartet. For å lage en uforanderlig, grunne kopi av et av disse kartene, kan vi bruke kopi av metode:

Map map = ImmutableMap.builder () .put ("emp1", emp1) .put ("emp2", emp2) .build (); Map shallowCopy = ImmutableMap.copyOf (kart); assertThat (shallowCopy) .isSameAs (kart);

6. Apache Commons Lang

Nå har Java ikke noen innebygde implementeringer av dype kopier. Så for å lage en dyp kopi, kan vi enten overstyre klone () metode eller bruke en serialisering-deserialiseringsteknikk.

Apache Commons har SerializationUtils med en klone () metode for å lage en dyp kopi. For dette må enhver klasse som inngår i dyp kopi implementere Serialiserbar grensesnitt:

offentlig klasse Ansatt implementerer Serialiserbar {// implementeringsdetaljer} HashMap deepCopy = SerializationUtils.clone (originalMap);

7. Konklusjon

I denne raske opplæringen har vi sett forskjellige teknikker for å kopiere en HashMap i Java, sammen med konseptet grunne og dype kopier for HashMaps.

Vi utforsket også noen av de eksterne bibliotekene som er ganske nyttige for å lage grunne og dype kopier.

Den komplette kildekoden til disse implementeringene sammen med enhetstestene er tilgjengelig i GitHub-prosjektet.