streamalism.org

1. Overzicht

In dit artikel kijken we naar PCollections, a Java-bibliotheek met blijvende, onveranderlijke collecties.

Persistente gegevensstructuren (verzamelingen) kunnen niet rechtstreeks worden gewijzigd tijdens de updatebewerking, maar er wordt een nieuw object met het resultaat van de updatebewerking geretourneerd. Ze zijn niet alleen onveranderlijk, maar ook persistent - en dat betekent dat nadat de wijziging is uitgevoerd, blijven eerdere versies van de collectie ongewijzigd.

PCollections is analoog aan en compatibel met het Java Collections-framework.

2. Afhankelijkheden

Laten we de volgende afhankelijkheid toevoegen aan onze pom.xml voor ons om PCollections in ons project te gebruiken:

 org.pcollections pcollections 2.1.2 

Als ons project op Gradle is gebaseerd, kunnen we hetzelfde artefact aan ons toevoegen build.gradle het dossier:

compileer 'org.pcollections: pcollections: 2.1.2'

De nieuwste versie is te vinden op Maven Central.

3. Kaartstructuur (HashPMap)

HashPMap is een persistente kaartgegevensstructuur. Het is de analoog voor java.util.HashMap gebruikt voor het opslaan van niet-null-sleutelwaardegegevens.

We kunnen instantiëren HashPMap door handige statische methoden te gebruiken in HashTreePMap. Deze statische methoden retourneren een HashPMap instantie die wordt ondersteund door een IntTreePMap.

De statische leeg() methode van de HashTreePMap class maakt een lege HashPMap dat geen elementen heeft - net zoals het gebruik van de standaardconstructor van java.util.HashMap:

HashPMap pmap = HashTreePMap.empty ();

Er zijn twee andere statische methoden die we kunnen gebruiken om te maken HashPMap. De singleton () methode creëert een HashPMap met slechts één vermelding:

HashPMap pmap1 = HashTreePMap.singleton ("key1", "value1"); assertEquals (pmap1.size (), 1);

De van() methode creëert een HashPMap van een bestaand java.util.HashMap instantie (en andere java.util.Map implementaties):

Map map = nieuwe HashMap (); map.put ("mkey1", "mval1"); map.put ("mkey2", "mval2"); HashPMap pmap2 = HashTreePMap.from (kaart); assertEquals (pmap2.size (), 2);

Hoewel HashPMap erft enkele van de methoden van java.util.AbstractMap en java.util.Map, het heeft methoden die er uniek voor zijn.

De minus() methode verwijdert een enkel item van de kaart terwijl de minusAll () methode verwijdert meerdere items. Er is ook de plus() en plusAll () methoden die respectievelijk enkele en meerdere items toevoegen:

HashPMap pmap = HashTreePMap.empty (); HashPMap pmap0 = pmap.plus ("key1", "value1"); Map map = nieuwe HashMap (); map.put ("key2", "val2"); map.put ("key3", "val3"); HashPMap pmap1 = pmap0.plusAll (kaart); HashPMap pmap2 = pmap1.minus ("key1"); HashPMap pmap3 = pmap2.minusAll (map.keySet ()); assertEquals (pmap0.size (), 1); assertEquals (pmap1.size (), 3); assertFalse (pmap2.containsKey ("key1")); assertEquals (pmap3.size (), 0);

Het is belangrijk op te merken dat bellen leggen() Aan pmap zal een UnsupportedOperationException. Omdat PCollections-objecten persistent en onveranderlijk zijn, retourneert elke wijzigingsoperatie een nieuw exemplaar van een object (HashPMap).

Laten we verder kijken naar andere datastructuren.

4. Lijststructuur (TreePVector en ConsPStack)

TreePVector is een hardnekkige analogie van java.util.ArrayList terwijl Nadelen PStack is de analoog van java.util.LinkedList. TreePVector en Nadelen PStack handige statische methoden hebben om nieuwe instanties te maken - net als HashPMap.

De leeg() methode creëert een lege TreePVector, Terwijl de singleton () methode creëert een TreePVector met slechts één element. Er is ook de van() methode die kan worden gebruikt om een ​​instantie van TreePVector van elk java.util.Collection.

Nadelen PStack heeft statische methoden met dezelfde naam die hetzelfde doel bereiken.

TreePVector heeft methoden om het te manipuleren. Het heeft de minus() en minusAll () methoden voor het verwijderen van element (en); de plus(), en plusAll () voor toevoeging van element (en).

De met() wordt gebruikt om een ​​element op een opgegeven index te vervangen, en de subLijst () haalt een scala aan elementen uit de collectie.

Deze methoden zijn beschikbaar in Nadelen PStack ook.

Laten we eens kijken naar het volgende codefragment dat een voorbeeld is van de hierboven genoemde methoden:

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");

In het bovenstaande codefragment pSub is een ander TreePVector object en is onafhankelijk van pV2. Zoals kan worden opgemerkt, pV2 werd niet veranderd door de subLijst () operatie; eerder een nieuwe TreePVector object is gemaakt en gevuld met elementen van pV2 van index 0 tot 2.

Dit wordt bedoeld met onveranderlijkheid en het is wat er gebeurt met alle modificerende methoden van PCollections.

5. Structuur instellen (MapPSet)

MapPSet is een hardnekkige, kaartgestuurde analoog van java.util.HashSet. Het kan gemakkelijk worden geïnstantieerd door statische methoden van HashTreePSet - leeg(), van() en singleton (). Ze werken op dezelfde manier als uitgelegd in eerdere voorbeelden.

MapPSet heeft plus(), plusAll (), minus() en minusAll () methoden voor het manipuleren van verzamelde gegevens. Bovendien erft het methoden van java.util.Set, java.util.AbstractCollection en 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"));

Ten slotte is er ook OrderedPSet - die de invoegvolgorde van elementen behoudt, net als java.util.LinkedHashSet.

6. Conclusie

Concluderend hebben we in deze korte tutorial PCollections onderzocht - de persistente datastructuren die analoog zijn aan kerncollecties die we beschikbaar hebben in Java. Natuurlijk geeft de PCollections Javadoc meer inzicht in de fijne kneepjes van de bibliotheek.

En, zoals altijd, is de volledige code te vinden op Github.