streamalism.org

1. Oversigt

I denne artikel vil vi se på PC-samlinger, a Java-bibliotek, der leverer vedvarende, uforanderlige samlinger.

Vedvarende datastrukturer (samlinger) kan ikke ændres direkte under opdateringsoperationen, snarere returneres et nyt objekt med resultatet af opdateringsoperationen. De er ikke kun uforanderlige, men også vedholdende - hvilket betyder det efter ændring er udført, forbliver tidligere versioner af samlingen uændret.

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

2. Afhængigheder

Lad os tilføje følgende afhængighed til vores pom.xml for os at bruge pc-samlinger i vores projekt:

 org.pcollections pcollections 2.1.2 

Hvis vores projekt er Gradle-baseret, kan vi tilføje den samme artefakt til vores build.gradle fil:

kompilere 'org.pcollections: pcollections: 2.1.2'

Den seneste version kan findes på Maven Central.

3. Kortstruktur (HashPMap)

HashPMap er en vedvarende kortdatastruktur. Det er den analoge til java.util.HashMap bruges til lagring af nøgleværdidata, der ikke er nul.

Vi kan øjeblikkeligt HashPMap ved hjælp af praktiske statiske metoder i HashTreePMap. Disse statiske metoder returnerer a HashPMap instans, der bakkes op af en IntTreePMap.

Det statiske tom() metode til HashTreePMap klasse opretter en tom HashPMap der har ingen elementer - ligesom at bruge standardkonstruktøren til java.util.HashMap:

HashPMap pmap = HashTreePMap.empty ();

Der er to andre statiske metoder, som vi kan bruge til at oprette HashPMap. Det singleton () metode skaber en HashPMap med kun en post:

HashPMap pmap1 = HashTreePMap.singleton ("nøgle1", "værdi1"); assertEquals (pmap1.size (), 1);

Det fra() metode skaber en HashPMap fra en eksisterende java.util.HashMap eksempel (og andet java.util.Kort implementeringer):

Kortkort = nyt HashMap (); map.put ("mkey1", "mval1"); map.put ("mkey2", "mval2"); HashPMap pmap2 = HashTreePMap.from (kort); assertEquals (pmap2.size (), 2);

Selvom HashPMap arver nogle af metoderne fra java.util.AbstractMap og java.util.Kort, det har metoder, der er unikke for det.

Det minus() metode fjerner en enkelt post fra kortet, mens minusAlle () metode fjerner flere poster. Der er også plus() og plusAlle () metoder, der tilføjer henholdsvis enkelte og flere poster:

HashPMap pmap = HashTreePMap.empty (); HashPMap pmap0 = pmap.plus ("nøgle1", "værdi1"); Kortkort = nyt HashMap (); map.put ("key2", "val2"); map.put ("key3", "val3"); HashPMap pmap1 = pmap0.plusAll (kort); HashPMap pmap2 = pmap1.minus ("nøgle1"); HashPMap pmap3 = pmap2.minusAll (map.keySet ()); assertEquals (pmap0.size (), 1); assertEquals (pmap1.size (), 3); assertFalse (pmap2.containsKey ("key1")); assertEquals (pmap3.size (), 0);

Det er vigtigt at bemærke det opkald sætte() på pmap vil kaste en Ikke-understøttetOperationException. Da PCollections-objekter er vedvarende og uforanderlige, returnerer hver ændringsoperation en ny forekomst af et objekt (HashPMap).

Lad os gå videre for at se på andre datastrukturer.

4. Listestruktur (TreePVector og ConsPStack)

TreePVector er en vedvarende analog af java.util.ArrayList mens UlemperPStack er analog af java.util.LinkedList. TreePVector og UlemperPStack har praktiske statiske metoder til at oprette nye forekomster - ligesom HashPMap.

Det tom() metode skaber en tom TreePVector, mens singleton () metode skaber en TreePVector med kun ét element. Der er også fra() metode, der kan bruges til at oprette en forekomst af TreePVector fra enhver java.util.Collection.

UlemperPStack har statiske metoder med samme navn, der opnår det samme mål.

TreePVector har metoder til at manipulere det. Det har minus() og minusAlle () metoder til fjernelse af element (er); det plus()og plusAlle () til tilføjelse af element (er).

Det med() bruges til at erstatte et element ved et specificeret indeks, og underliste () får en række elementer fra samlingen.

Disse metoder er tilgængelige i UlemperPStack såvel.

Lad os overveje følgende kodestykke, der eksemplificerer de ovennævnte metoder:

TreePVector pVector = TreePVector.empty (); TreePVector pV1 = pVector.plus ("e1"); TreePVector pV2 = pV1.plusAll (Arrays.asList ("e2", "e3", "e4")); assertEquals (1, pV1.størrelse ()); 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 kodestykket ovenfor, pSub er en anden TreePVector objekt og er uafhængig af pV2. Som det kan ses, pV2 blev ikke ændret af underliste () operation; snarere en ny TreePVector objekt blev oprettet og fyldt med elementer af pV2 fra indeks 0 til 2.

Dette er hvad der menes med uforanderlighed, og det er hvad der sker med alle modificerende metoder til pc-samlinger.

5. Indstil struktur (MapPSet)

MapPSet er en vedvarende, kortbaseret, analog af java.util.HashSet. Det kan bekvemt instantieres ved hjælp af statiske metoder til HashTreePSet - tom(), fra() og singleton (). De fungerer på samme måde som forklaret i tidligere eksempler.

MapPSet har plus(), plusAlle (), minus() og minusAlle () metoder til manipulation af sætdata. Desuden arver den metoder fra java.util.Set, 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 der også Bestilt PSet - som opretholder indsætningsrækkefølgen af ​​elementer ligesom java.util.LinkedHashSet.

6. Konklusion

Afslutningsvis undersøgte vi i denne hurtige vejledning pc-samlinger - de vedvarende datastrukturer, der er analoge med kernesamlinger, vi har til rådighed i Java. Selvfølgelig giver PC-samlingerne Javadoc mere indsigt i bibliotekets forviklinger.

Og som altid kan den komplette kode findes på Github.