Inleiding tot Eclipse-collecties

1. Overzicht

Eclipse Collections is een ander verbeterd verzamelframework voor Java.

Simpel gezegd, het biedt geoptimaliseerde implementaties en enkele aanvullende gegevensstructuren en functies die niet in de kern van Java voorkomen.

De bibliotheek biedt zowel veranderlijke als onveranderlijke implementaties van alle datastructuren.

2. Maven Afhankelijkheid

Laten we beginnen met het toevoegen van de volgende Maven-afhankelijkheid aan onze pom.xml:

We kunnen de laatste versie van de bibliotheek vinden in de Maven Central Repository.

3. Het grote geheel

3.1. Soorten basiscollecties

Basiscollectietypen in Eclipse Collections zijn:

  • ListIterable - een geordende collectie die de invoegvolgorde handhaaft en dubbele elementen toestaat. Subinterfaces zijn onder meer: MutableList, FixedSizeList en Onveranderlijke lijst. De meest voorkomende De implementatie van ListIterable is FastList, een subklasse van MutableList
  • Instelbaar - een verzameling die geen dubbele elementen toestaat. Het kan gesorteerd of ongesorteerd zijn. Subinterfaces zijn onder meer: SortedSetIterable en UnsortedSetIterable. De meest voorkomende ongesorteerd Instelbaar implementatie is UnifiedSet
  • MapIterable - een verzameling sleutel / waarde-paren. Subinterfaces zijn onder meer MutableMap, FixedSizeMap en Onveranderlijke kaart. Twee veel voorkomende implementaties zijn UnifiedMap en MutableSortedMap. Terwijl UnifiedMap handhaaft geen enkele volgorde, MutableSortedMap handhaaft de natuurlijke volgorde van elementen
  • BiMap - een verzameling sleutel / waarde-paren die in beide richtingen kunnen worden herhaald. BiMap breidt de MapIterable koppel
  • Zak - een ongeordende verzameling die duplicaten toestaat. Subinterfaces zijn onder meer MutableBag enFixedSizeBag. De meest voorkomende implementatie is HashBag
  • Stapelbaar - een collectie die de volgorde "last-in, first-out" handhaaft, waarbij de elementen in omgekeerde volgorde van invoeging worden doorlopen. Subinterfaces zijn onder meer MutableStack en Onveranderlijke stapel
  • MultiMap - een verzameling sleutel / waarde-paren waarmee meerdere waarden voor elke sleutel mogelijk zijn

3.2. Primitieve collecties

Het raamwerk biedt ook een enorme reeks primitieve collecties; hun implementaties zijn genoemd naar het type dat ze hebben. Er zijn veranderlijke, onveranderlijke, gesynchroniseerde en niet-wijzigbare vormen voor elk type ervan:

  • Primitief Lijsten
  • Primitief Sets
  • Primitief Stapels
  • Primitief Tassen
  • Primitief Kaarten
  • IntInterval

Er is een groot aantal primitieve kaartvormen die alle mogelijke combinaties van ofwel primitieve sleutels ofwel objectsleutels en ofwel primitieve ofwel objectwaarden omvatten.

Een korte opmerking - een IntInterval is een reeks gehele getallen die kunnen worden herhaald met behulp van een stapwaarde.

4. Instantiëren van een collectie

Om elementen toe te voegen aan een ArrayList of HashSet, instantiëren we een verzameling door de constructor no-arg aan te roepen en vervolgens elk element een voor een toe te voegen.

Hoewel we dat nog steeds kunnen doen in Eclipse Collections, we kunnen ook een verzameling instantiëren en alle initiële elementen tegelijkertijd op één regel aanbieden.

Laten we eens kijken hoe we een FastList:

MutableList list = FastList.newListWith ("Porsche", "Volkswagen", "Toyota", "Mercedes", "Toyota");

Evenzo kunnen we een UnifiedSet en voeg er elementen aan toe door de elementen door te geven aan de newSetWith () statische methode:

Setvergelijking = UnifiedSet.newSetWith ("Porsche", "Volkswagen", "Toyota", "Mercedes");

Hier leest u hoe we een HashBag:

MutableBag bag = HashBag.newBagWith ("Porsche", "Volkswagen", "Toyota", "Porsche", "Mercedes");

Het instantiëren van kaarten en het toevoegen van sleutel- en waardeparen is vergelijkbaar. Het enige verschil is dat we de sleutel- en waardeparen doorgeven aan de newMapWith () methode als implementaties van de Paar koppel.

Laten we nemen UnifiedMap als voorbeeld:

Paar paar1 = Tuples.pair (1, "Een"); Paar paar2 = Tuples.pair (2, "Twee"); Paar paar3 = Tuples.pair (3, "Drie"); UnifiedMap-kaart = nieuwe UnifiedMap (paar1, paar2, paar3);

We kunnen nog steeds de Java Collections API-benadering gebruiken:

UnifiedMap-kaart = nieuwe UnifiedMap (); map.put (1, "een"); map.put (2, "twee"); map.put (3, "drie");

Sinds onveranderlijke verzamelingen kunnen niet worden gewijzigd, ze hebben geen implementaties van methoden die verzamelingen wijzigen zoals toevoegen() en verwijderen().

Niet-wijzigbare verzamelingen staan ​​ons echter toe om deze methoden aan te roepen, maar zullen een UnsupportedOperationException als we dat doen.

5. Elementen ophalen uit verzamelingen

Net als bij het gebruik van standaard Lijsten, elementen van Eclipse Collections Lijsten kunnen worden opgehaald door hun index:

lijst.get (0);

En waarden van Eclipse Collections-kaarten kunnen worden opgehaald met behulp van hun sleutel:

map.get (0);

De getFirst () en word laatste() methoden kunnen worden gebruikt om respectievelijk het eerste en het laatste element van een lijst op te halen. In het geval van andere verzamelingen, retourneren ze het eerste en het laatste element dat door een iterator zou worden geretourneerd.

map.getFirst (); map.getLast ();

De methodes max () en min () kan worden gebruikt om de maximale en minimale waarden van een collectie te krijgen op basis van de natuurlijke ordening.

map.max (); map.min ();

6. Een verzameling herhalen

Eclipse Collections biedt vele manieren om door collecties te herhalen. Laten we eens kijken wat ze zijn en hoe ze in de praktijk werken.

6.1. Collectie filteren

Het geselecteerde patroon retourneert een nieuwe verzameling met elementen van een verzameling die voldoen aan een logische voorwaarde. Het is in wezen een filteroperatie.

Hier is een voorbeeld:

@Test openbare ongeldig gegevenListwhenSelect_thenCorrect () {MutableList groterThanThirty = lijst .select (Predicates.greaterThan (30)) .sortThis (); Assertions.assertThat (moreThanThirty) .containsExactly (31, 38, 41); }

Hetzelfde kan worden gedaan met behulp van een eenvoudige lambda-uitdrukking:

lijst terug. selecteer (i -> i> 30). sortThis ();

Het afwijzingspatroon is het tegenovergestelde. Het retourneert een verzameling van alle elementen die niet aan een logische voorwaarde voldoen.

Laten we een voorbeeld bekijken:

@Test openbare leegte whenReject_thenCorrect () {MutableList notGreaterThanThirty = lijst .reject (Predicates.greaterThan (30)) .sortThis (); Assertions.assertThat (notGreaterThanThirty) .containsExactlyElementsOf (this.expectedList); }

Hier verwerpen we alle elementen die groter zijn dan 30.

6.2. De verzamelen() Methode

De verzamelen methode retourneert een nieuwe verzameling waarvan de elementen de resultaten zijn die worden geretourneerd door de opgegeven lambda-expressie - in wezen is het een combinatie van de kaart() en verzamelen() van Stream API.

Laten we het in actie zien:

@Test public void whenCollect_thenCorrect () {Student student1 = nieuwe student ("John", "Hopkins"); Student student2 = nieuwe student ("George", "Adams"); MutableList students = FastList .newListWith (student1, student2); MutableList lastNames = students .collect (Student :: getLastName); Assertions.assertThat (lastNames) .containsExactly ("Hopkins", "Adams"); }

De gemaakte collectie achternamen bevat de achternamen die zijn verzameld van de studenten lijst.

Maar, wat als de geretourneerde verzameling een verzameling verzamelingen is en we geen geneste structuur willen behouden?

Als elke student bijvoorbeeld meerdere adressen heeft en we een collectie nodig hebben die de adressen bevat als Snaren in plaats van een verzameling verzamelingen kunnen we de flatCollect () methode.

Hier is een voorbeeld:

@Test openbare leegte whenFlatCollect_thenCorrect () {MutableList-adressen = studenten .flatCollect (Student :: getAddresses); Assertions.assertThat (adressen) .containsExactlyElementsOf (this.expectedAddresses); }

6.3. Element detectie

De detecteren methode zoekt en retourneert het eerste element dat aan een logische voorwaarde voldoet.

Laten we een kort voorbeeld bekijken:

@Test openbare leegte whenDetect_thenCorrect () {Integer resultaat = lijst.detect (Predicates.greaterThan (30)); Assertions.assertThat (resultaat) .isEqualTo (41); }

De voldoen aan methode bepaalt of een element van een verzameling aan een logische voorwaarde voldoet.

Hier is een voorbeeld:

@Test openbare leegte whenAnySatisfiesCondition_thenCorrect () {booleaans resultaat = list.anySatisfy (Predicates.greaterThan (30)); assertTrue (resultaat); }

Evenzo is het alle voldoen methode bepaalt of alle elementen van een collectie voldoen aan een logische voorwaarde.

Laten we een snel voorbeeld bekijken:

@Test openbare leegte whenAnySatisfiesCondition_thenCorrect () {booleaans resultaat = list.allSatisfy (Predicates.greaterThan (0)); assertTrue (resultaat); }

6.4. De partitie () Methode

De partitie method wijst elk element van een collectie toe aan een van de twee collecties, afhankelijk van of het element al dan niet aan een logische voorwaarde voldoet.

Laten we een voorbeeld bekijken:

@Test openbare leegte whenAnySatisfiesCondition_thenCorrect () {MutableList nummers = lijst; PartitionMutableList partitionedFolks = nummers .partition (i -> i> 30); MutableList groterThanThirty = partitionedFolks .getSelected () .sortThis (); MutableList smallThanThirty = partitionedFolks .getRejected () .sortThis (); Assertions.assertThat (smallerThanThirty) .containsExactly (1, 5, 8, 17, 23); Assertions.assertThat (moreThanThirty) .containsExactly (31, 38, 41); }

6.5. Luie herhaling

Luie iteratie is een optimalisatiepatroon waarin een iteratiemethode wordt aangeroepen, maar de daadwerkelijke uitvoering ervan wordt uitgesteld totdat de actie of retourwaarden vereist zijn door een andere volgende methode.

@Test public void whenLazyIteration_thenCorrect () {Student student1 = nieuwe student ("John", "Hopkins"); Student student2 = nieuwe student ("George", "Adams"); Student student3 = nieuwe student ("Jennifer", "Rodriguez"); MutableList students = Lists.mutable .with (student1, student2, student3); LazyIterable lazyStudents = students.asLazy (); LazyIterable lastNames = lazyStudents .collect (Student :: getLastName); Assertions.assertThat (lastNames) .containsAll (Lists.mutable.with ("Hopkins", "Adams", "Rodriguez")); }

Hier de lui studenten object haalt de elementen van het studenten lijst tot de verzamelen() methode wordt genoemd.

7. Verzamelelementen koppelen

De methode zip () geeft een nieuwe collectie terug door elementen van twee collecties in paren te combineren. Als een van de twee verzamelingen langer is, worden de resterende elementen afgekapt.

Laten we eens kijken hoe we het kunnen gebruiken:

@Test public void whenZip_thenCorrect () {MutableList numbers = Lists.mutable .with ("1", "2", "3", "Ignored"); MutableList cars = Lists.mutable .with ("Porsche", "Volvo", "Toyota"); MutableList paren = nummers.zip (auto's); Assertions.assertThat (paren) .containsExactlyElementsOf (this.expectedPairs); }

We kunnen ook de elementen van een collectie koppelen aan hun indexen met behulp van de zipWithIndex () methode:

@Test public void whenZip_thenCorrect () {MutableList cars = FastList .newListWith ("Porsche", "Volvo", "Toyota"); MutableList paren = cars.zipWithIndex (); Assertions.assertThat (paren) .containsExactlyElementsOf (this.expectedPairs); }

8. Verzamelingen converteren

Eclipse Collections biedt eenvoudige methoden voor het converteren van een containertype naar een ander. Deze methoden zijn toList (), toSet (), toBag () en in kaart brengen().

Laten we eens kijken hoe we ze kunnen gebruiken:

openbare statische lijst convertToList () {UnifiedSet cars = nieuwe UnifiedSet (); cars.add ("Toyota"); cars.add ("Mercedes"); cars.add ("Volkswagen"); retourneer cars.toList (); }

Laten we onze test uitvoeren:

@ Test openbare ongeldig whenConvertContainerToAnother_thenCorrect () {MutableList cars = (MutableList) ConvertContainerToAnother .convertToList (); Assertions.assertThat (auto's) .containsExactlyElementsOf (FastList.newListWith ("Volkswagen", "Toyota", "Mercedes")); }

9. Conclusie

In deze tutorial hebben we een kort overzicht gezien van Eclipse Collections en de functies die ze bieden.

De volledige implementatie van deze tutorial is beschikbaar op GitHub.