Introduktion til solformørkelsessamlinger

1. Oversigt

Eclipse Collections er en anden forbedret samlingsramme for Java.

Kort sagt, det giver optimerede implementeringer samt nogle yderligere datastrukturer og funktioner, som ikke findes i kernen Java.

Biblioteket giver både ændrede og uforanderlige implementeringer af alle datastrukturer.

2. Maven-afhængighed

Lad os starte med at tilføje følgende Maven-afhængighed til vores pom.xml:

Vi kan finde den nyeste version af biblioteket i Maven Central Repository.

3. Det store billede

3.1. Grundlæggende samlingstyper

Grundlæggende samlingstyper i Eclipse Collections er:

  • ListeIterabel - en ordnet samling, der opretholder indsætningsordre og tillader duplikatelementer. Undergrænseflader inkluderer: MutableList, FixedSizeList og ImmutableList. Den mest almindelige ListIterable implementering er FastList, som er en underklasse af MutableList
  • SetIterable - en samling, der ikke tillader duplikatelementer. Det kan sorteres eller usorteres. Undergrænseflader inkluderer: SortedSetIterable og UnsortedSetIterable. Den mest almindelige usorterede SetIterable implementering er UnifiedSet
  • KortIterabel - en samling af nøgle / værdipar. Undergrænseflader inkluderer MutableMap, FixedSizeMap og ImmutableMap. To almindelige implementeringer er UnifiedMap og MutableSortedMap. Mens UnifiedMap opretholder ingen ordre, MutableSortedMap opretholder den naturlige rækkefølge af elementer
  • BiMap - en samling af nøgle / værdipar, der kan gentages i begge retninger. BiMap udvider KortIterabel interface
  • Taske - en uordnet samling, der tillader duplikater. Undergrænseflader inkluderer MutableBag ogFixedSizeBag. Den mest almindelige implementering er HashBag
  • StackIterable - en samling, der opretholder "sidste-i-først-ud" -rækkefølge, der gentages gennem elementer i omvendt indsætningsrækkefølge. Undergrænseflader inkluderer MutableStack og ImmutableStack
  • MultiMap - en samling nøgle / værdipar, der tillader flere værdier for hver nøgle

3.2. Primitive samlinger

Rammen giver også et stort sæt primitive samlinger; deres implementeringer er opkaldt efter den type, de har. Der er foranderlige, uforanderlige, synkroniserede og umodificerbare former for hver type af dem:

  • Primitiv Lister
  • Primitiv Sæt
  • Primitiv Stakke
  • Primitiv Tasker
  • Primitiv Kort
  • IntInterval

Der er et stort antal primitive kortformer, der dækker alle mulige kombinationer af enten primitive eller objektnøgler og enten primitive eller objektværdier.

En hurtig note - en IntInterval er en række heltal, der kan gentages ved hjælp af en trinværdi.

4. Instantiering af en samling

For at tilføje elementer til en ArrayList eller HashSet, instantierer vi en samling ved at kalde konstruktøren no-arg og derefter tilføje hvert element en efter en.

Mens vi stadig kan gøre det i formørkelsessamlinger, Vi kan også instantiere en samling og levere alle indledende elementer på samme tid i en enkelt linje.

Lad os se, hvordan vi kan instantiere en Hurtigliste:

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

På samme måde kan vi instantiere en UnifiedSet og tilføj elementer til det ved at sende elementerne til newSetWith () statisk metode:

Sæt sammenligning = UnifiedSet.newSetWith ("Porsche", "Volkswagen", "Toyota", "Mercedes");

Sådan kan vi instantiere en HashBag:

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

Instantiering af kort og tilføjelse af nøgle- og værdipar til dem er ens. Den eneste forskel er, at vi videregiver nøgle- og værdipar til newMapWith () metode som implementeringer af Par interface.

Lad os tage UnifiedMap som et eksempel:

Par par1 = Tuples.pair (1, "One"); Par par2 = Tuples.pair (2, "To"); Par par3 = Tuples.pair (3, "Tre"); UnifiedMap-kort = nyt UnifiedMap (par1, par2, par3);

Vi kan stadig bruge tilgangen til Java Collections API:

UnifiedMap-kort = nyt UnifiedMap (); map.put (1, "en"); map.put (2, "to"); map.put (3, "tre");

Siden uforanderlige samlinger kan ikke ændres, de har ikke implementeringer af metoder, der ændrer samlinger såsom tilføje() og fjerne().

Uændrede samlinger tillader os dog at kalde disse metoder, men vil kaste et Ikke-understøttetOperationException hvis vi gør det.

5. Henter elementer fra samlinger

Ligesom at bruge standard Lister, elementer i Eclipse Collections Lister kan hentes ved hjælp af deres indeks:

list.get (0);

Og værdier for Eclipse Collections-kort kan hentes ved hjælp af deres nøgle:

map.get (0);

Det getFirst () og getLast () metoder kan bruges til at hente henholdsvis første og sidste element på en liste. I tilfælde af andre samlinger returnerer de det første og det sidste element, der ville blive returneret af en iterator.

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

Metoderne maks () og min () kan bruges til at få de maksimale og minimale værdier for en samling baseret på den naturlige rækkefølge.

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

6. Iterering over en samling

Eclipse Collections giver mange måder at gentage over samlinger. Lad os se, hvad de er, og hvordan de arbejder i praksis.

6.1. Samlingsfiltrering

Valgmønsteret returnerer en ny samling, der indeholder elementer i en samling, der opfylder en logisk tilstand. Det er i det væsentlige en filtreringsoperation.

Her er et eksempel:

@Test offentlig ugyldighed givenListwhenSelect_thenCorrect () {MutableList greaterThanThirty = liste .select (Predicates.greaterThan (30)) .sortThis (); Assertions.assertThat (greaterThanThirty) .containsExactly (31, 38, 41); }

Den samme ting kan gøres ved hjælp af et enkelt lambda-udtryk:

returliste. vælg (i -> i> 30). sortThis ();

Afvisningsmønsteret er det modsatte. Den returnerer en samling af alle de elementer, der ikke opfylder en logisk betingelse.

Lad os se et eksempel:

@Test offentligt ugyldigt nårReject_thenCorrect () {MutableList notGreaterThanThirty = list .reject (Predicates.greaterThan (30)) .sortThis (); Assertions.assertThat (notGreaterThanThirty) .containsExactlyElementsOf (this.expectedList); }

Her afviser vi alle elementer, der er større end 30.

6.2. Det indsamle() Metode

Det indsamle metoden returnerer en ny samling, hvis elementer er de resultater, der returneres af det angivne lambda-udtryk - det er i det væsentlige en kombination af kort() og indsamle() fra Stream API.

Lad os se det i aktion:

@Test offentligt ugyldigt nårCollect_thenCorrect () {Student student1 = ny elev ("John", "Hopkins"); Studerende student2 = ny studerende ("George", "Adams"); MutableList studerende = FastList .newListWith (student1, student2); MutableList lastNames = students .collect (Student :: getLastName); Assertions.assertThat (lastNames) .containsExactly ("Hopkins", "Adams"); }

Den oprettede samling efternavne indeholder de efternavne, der er indsamlet fra studerende liste.

Men, hvad hvis den returnerede samling er en samling af samlinger, og vi ikke ønsker at opretholde en indlejret struktur?

For eksempel, hvis hver elev har flere adresser, og vi har brug for en samling, der indeholder adresserne som Strenge snarere end en samling af samlinger, kan vi bruge flatCollect () metode.

Her er et eksempel:

@Test offentlig ugyldig nårFlatCollect_thenCorrect () {MutableList-adresser = studerende .flatCollect (Student :: getAddresses); Assertions.assertThat (adresser) .containsExactlyElementsOf (this.expectedAddresses); }

6.3. Elementdetektion

Det opdage metoden finder og returnerer det første element, der opfylder en logisk tilstand.

Lad os gå over et hurtigt eksempel:

@Test offentligt ugyldigt nårDetect_thenCorrect () {Heltalsresultat = list.detect (Predicates.greaterThan (30)); Assertions.assertThat (result) .isEqualTo (41); }

Det anyStily metode bestemmer, om et element i en samling opfylder en logisk tilstand.

Her er et eksempel:

@Test offentligt ugyldigt nårAnySatisfiesCondition_thenCorrect () {boolean result = list.anySatisfy (Predicates.greaterThan (30)); assertTrue (resultat); }

Tilsvarende er alt Tilfreds metode bestemmer, om alle elementer i en samling opfylder en logisk tilstand.

Lad os se et hurtigt eksempel:

@Test offentlig ugyldig nårAnySatisfiesCondition_thenCorrect () {boolean result = list.allSatisfy (Predicates.greaterThan (0)); assertTrue (resultat); }

6.4. Det skillevæg() Metode

Det skillevæg metoden tildeler hvert element i en samling i en af ​​to samlinger afhængigt af om elementet opfylder en logisk tilstand eller ej.

Lad os se et eksempel:

@Test offentligt ugyldigt nårAnySatisfiesCondition_thenCorrect () {MutableList numre = liste; PartitionMutableList partitionedFolks = tal .partition (i -> i> 30); MutableList greaterThanThirty = partitionedFolks .getSelected () .sortThis (); MutableList smallerThanThirty = partitionedFolks .getRejected () .sortThis (); Assertions.assertThat (smallerThanThirty) .containsExactly (1, 5, 8, 17, 23); Assertions.assertThat (greaterThanThirty) .containsExactly (31, 38, 41); }

6.5. Lazy gentagelse

Lazy iteration er et optimeringsmønster, hvor en iterationsmetode påberåbes, men dens faktiske udførelse udsættes, indtil dens handling eller returværdier kræves af en anden efterfølgende metode.

@Test offentligt ugyldigt nårLazyIteration_thenCorrect () {Student student1 = ny elev ("John", "Hopkins"); Studerende student2 = ny studerende ("George", "Adams"); Studentstudent3 = ny elev ("Jennifer", "Rodriguez"); MutableList studerende = 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")); }

Her, den lazyStudents objektet henter ikke elementerne i studerende liste indtil indsamle() metode kaldes.

7. Parring af indsamlingselementer

Metoden lynlås () returnerer en ny samling ved at kombinere elementer i to samlinger i par. Hvis nogen af ​​de to samlinger er længere, afkortes de resterende elementer.

Lad os se, hvordan vi kan bruge det:

@Test offentligt ugyldigt nårZip_thenCorrect () {MutableList numbers = Lists.mutable .with ("1", "2", "3", "Ignored"); MutableList biler = Lists.mutable .with ("Porsche", "Volvo", "Toyota"); MutableList par = numbers.zip (biler); Assertions.assertThat (pair) .containsExactlyElementsOf (this.expectedPairs); }

Vi kan også parre en samlings elementer med deres indekser ved hjælp af zipWithIndex () metode:

@Test offentligt ugyldigt nårZip_thenCorrect () {MutableList biler = FastList .newListWith ("Porsche", "Volvo", "Toyota"); MutableList par = biler.zipWithIndex (); Assertions.assertThat (pair) .containsExactlyElementsOf (this.expectedPairs); }

8. Konvertering af samlinger

Eclipse Collections giver enkle metoder til konvertering af en containertype til en anden. Disse metoder er toList (), at sætte(), toBag () og at kortlægge().

Lad os se, hvordan vi kan bruge dem:

offentlig statisk liste convertToList () {UnifiedSet biler = nye UnifiedSet (); biler.add ("Toyota"); cars.add ("Mercedes"); biler.add ("Volkswagen"); returnere biler.toListe (); }

Lad os køre vores test:

@Test offentlig ugyldig nårConvertContainerToAnother_thenCorrect () {MutableList biler = (MutableList) ConvertContainerToAnother .convertToList (); Assertions.assertThat (biler) .containsExactlyElementsOf (FastList.newListWith ("Volkswagen", "Toyota", "Mercedes")); }

9. Konklusion

I denne vejledning har vi set et hurtigt overblik over Eclipse Collections og de funktioner, de giver.

Den fulde implementering af denne vejledning er tilgængelig på GitHub.