streamalism.org

1. Oversikt

I denne artikkelen vil vi se på PC-samlinger, a Java-bibliotek som gir vedvarende, uforanderlige samlinger.

Vedvarende datastrukturer (samlinger) kan ikke endres direkte under oppdateringsoperasjonen, snarere returneres et nytt objekt med resultatet av oppdateringsoperasjonen. De er ikke bare uforanderlige, men også vedvarende - noe som betyr det etter endring er utført forblir tidligere versjoner av samlingen uendret.

PCollections er analog med og kompatibel med Java Collections-rammeverket.

2. Avhengigheter

La oss legge til følgende avhengighet til vår pom.xml for oss å bruke PC-samlinger i prosjektet vårt:

 org.pcollections pcollections 2.1.2 

Hvis prosjektet vårt er Gradle-basert, kan vi legge til samme gjenstand i vår build.gradle fil:

kompilere 'org.pcollections: pcollections: 2.1.2'

Den siste versjonen finner du på Maven Central.

3. Kartstruktur (HashPMap)

HashPMap er en vedvarende kartdatastruktur. Det er den analoge for java.util.HashMap brukes til lagring av nøkkelverdidata som ikke er null.

Vi kan instantiere HashPMap ved å bruke praktiske statiske metoder i HashTreePMap. Disse statiske metodene returnerer a HashPMap forekomst som støttes av en IntTreePMap.

Det statiske tømme() metoden for HashTreePMap klasse skaper en tom HashPMap som ikke har noen elementer - akkurat som å bruke standardkonstruktøren til java.util.HashMap:

HashPMap pmap = HashTreePMap.empty ();

Det er to andre statiske metoder som vi kan bruke til å lage HashPMap. De singleton () metoden skaper en HashPMap med bare én oppføring:

HashPMap pmap1 = HashTreePMap.singleton ("nøkkel1", "verdi1"); assertEquals (pmap1.size (), 1);

De fra() metoden skaper en HashPMap fra en eksisterende java.util.HashMap forekomst (og annet java.util.Kart implementeringer):

Kartkart = nytt HashMap (); map.put ("mkey1", "mval1"); map.put ("mkey2", "mval2"); HashPMap pmap2 = HashTreePMap.from (kart); assertEquals (pmap2.size (), 2);

Selv om HashPMap arver noen av metodene fra java.util.AbstractMap og java.util.Kart, den har metoder som er unike for den.

De minus() metoden fjerner en enkelt oppføring fra kartet mens minusAlle () metoden fjerner flere oppføringer. Det er også i tillegg til() og plussAlle () metoder som legger til henholdsvis enkelt og flere oppføringer:

HashPMap pmap = HashTreePMap.empty (); HashPMap pmap0 = pmap.plus ("nøkkel1", "verdi1"); Kartkart = nytt HashMap (); map.put ("key2", "val2"); map.put ("key3", "val3"); HashPMap pmap1 = pmap0.plusAll (kart); HashPMap pmap2 = pmap1.minus ("nøkkel1"); HashPMap pmap3 = pmap2.minusAll (map.keySet ()); assertEquals (pmap0.size (), 1); assertEquals (pmap1.size (), 3); assertFalse (pmap2.containsKey ("key1")); assertEquals (pmap3.size (), 0);

Det er viktig å merke seg at det ringer sette() på pmap vil kaste en Ikke-støttetOperationException. Siden PCollections-objekter er vedvarende og uforanderlige, returnerer hver modifiserende operasjon en ny forekomst av et objekt (HashPMap).

La oss gå videre for å se på andre datastrukturer.

4. Listestruktur (TreePVector og ConsPStack)

TreePVector er en vedvarende analog av java.util.ArrayList samtidig som ConsPStack er analog av java.util.LinkedList. TreePVector og ConsPStack har praktiske statiske metoder for å opprette nye forekomster - akkurat som HashPMap.

De tømme() metoden skaper en tom TreePVector, mens singleton () metoden skaper en TreePVector med bare ett element. Det er også fra() metode som kan brukes til å lage en forekomst av TreePVector fra hvilken som helst java.util.Collection.

ConsPStack har statiske metoder med samme navn som oppnår samme mål.

TreePVector har metoder for å manipulere det. Den har minus() og minusAlle () metoder for fjerning av element (er); de i tillegg til(), og plussAlle () for tillegg av element (er).

De med() brukes til å erstatte et element ved en spesifisert indeks, og underliste () får en rekke elementer fra samlingen.

Disse metodene er tilgjengelige i ConsPStack også.

La oss vurdere følgende kodebit som eksemplifiserer metodene nevnt ovenfor:

TreePVector pVector = TreePVector.empty (); TreePVector pV1 = pVector.plus ("e1"); TreePVector pV2 = pV1.plusAll (Arrays.asList ("e2", "e3", "e4")); assertEquals (1, pV1.size ()); assertEquals (4, pV2.size ()); TreePVector pV3 = pV2.minus ("e1"); TreePVector pV4 = pV3.minusAll (Arrays.asList ("e2", "e3", "e4")); assertEquals (pV3.size (), 3); assertEquals (pV4.size (), 0); TreePVector pSub = pV2.subList (0, 2); assertTrue (pSub.contains ("e1") && pSub.contains ("e2")); TreePVector pVW = (TreePVector) pV2.with (0, "e10"); assertEquals (pVW.get (0), "e10");

I kodebiten ovenfor, pSub er en annen TreePVector objekt og er uavhengig av pV2. Som det kan observeres, pV2 ble ikke endret av underliste () operasjon; heller en ny TreePVector objekt ble opprettet og fylt med elementer av pV2 fra indeks 0 til 2.

Dette er hva som menes med uforanderlighet, og det er hva som skjer med alle modifiserende metoder for PC-samlinger.

5. Sett struktur (MapPSet)

MapPSet er en vedvarende, kartstøttet, analog av java.util.HashSet. Det kan enkelt instanseres ved hjelp av statiske metoder for HashTreePSet - tømme(), fra() og singleton (). De fungerer på samme måte som forklart i tidligere eksempler.

MapPSet har i tillegg til(), plussAlle (), minus() og minusAlle () metoder for å manipulere settdata. Videre arver den metoder fra java.util.Sett, java.util.AbstractCollection og java.util.AbstractSet:

MapPSet pSet = HashTreePSet.empty () .plusAll (Arrays.asList ("e1", "e2", "e3", "e4")); assertEquals (pSet.size (), 4); MapPSet pSet1 = pSet.minus ("e4"); assertFalse (pSet1.contains ("e4"));

Endelig er det også Bestilt PSet - som opprettholder innsettingsrekkefølgen for elementer akkurat som java.util.LinkedHashSet.

6. Konklusjon

Avslutningsvis, i denne raske opplæringen, utforsket vi PC-samlinger - de vedvarende datastrukturene som er analoge med kjernesamlingene vi har tilgjengelig i Java. Selvfølgelig gir PC-samlingene Javadoc mer innsikt i komplikasjonene i biblioteket.

Og som alltid kan den fullstendige koden finnes på Github.