Bevezetés az Eclipse gyűjteményekbe

1. Áttekintés

Az Eclipse Collections egy újabb továbbfejlesztett Java-keretrendszer.

Egyszerűen fogalmazva, optimalizált megvalósításokat, valamint néhány további adatstruktúrát és szolgáltatást nyújt, amelyek nem találhatók meg a Java alapmagában.

A könyvtár az összes adatstruktúra módosítható és megváltoztathatatlan megvalósítását biztosítja.

2. Maven-függőség

Kezdjük azzal, hogy hozzáadjuk a következő Maven-függőséget a mi pom.xml:

A könyvtár legújabb verzióját a Maven központi adattárában találhatjuk meg.

3. A nagy kép

3.1. Alapvető gyűjteménytípusok

Az Eclipse gyűjtemények alapvető gyűjteménytípusai:

  • ListIterable - rendezett gyűjtemény, amely fenntartja a beszúrási sorrendet és lehetővé teszi az ismétlődő elemeket. Az alfelületek a következők: MutableList, FixedSizeList és ImmutableList. A leggyakrabban A ListIterable megvalósítás a FastList, amely a MutableList egyik alosztálya
  • SetIterable - olyan gyűjtemény, amely nem engedélyez duplikált elemeket. Rendezhető vagy válogathatatlan. Az alfelületek a következők: SortedSetIterable és UnsortedSetIterable. A leggyakoribb válogatatlan SetIterable megvalósítás az UnifiedSet
  • MapIterable - kulcs / érték párok gyűjteménye. Az alfelületek közé tartozik MutableMap, FixedSizeMap és ImmutableMap. Két közös megvalósítás UnifiedMap és MutableSortedMap. Míg UnifiedMap nem tart fenn rendet, MutableSortedMap fenntartja az elemek természetes rendjét
  • BiMap - kulcs- és értékpárok gyűjteménye, amelyek mindkét irányban iterálhatók. BiMap kiterjeszti a MapIterable felület
  • Táska - rendezetlen gyűjtemény, amely lehetővé teszi a másolatokat. Az alfelületek közé tartozik MutableBag ésFixedSizeBag. A leggyakoribb megvalósítás az HashBag
  • StackIterable - a „last-in, first-out” sorrendet fenntartó gyűjtemény, amely az elemek között fordított beillesztési sorrendben iterál. Az alfelületek közé tartozik MutableStack és ImmutableStack
  • MultiMap - kulcs / érték párok gyűjteménye, amely minden kulcshoz több értéket tesz lehetővé

3.2. Ősgyűjtemények

A keretrendszer hatalmas primitív gyűjteményeket is kínál; megvalósításaik a birtokukba eső típusról vannak elnevezve. Mindegyik típushoz vannak módosítható, megváltoztathatatlan, szinkronizált és módosíthatatlan formák:

  • Primitív Listák
  • Primitív Készletek
  • Primitív Verem
  • Primitív Táskák
  • Primitív Térképek
  • IntInterval

Hatalmas számú primitív térképforma található, amelyek lefedik a primitív vagy az objektumkulcs és az primitív vagy az objektumértékek összes lehetséges kombinációját.

Gyors megjegyzés - an IntInterval olyan egész számtartomány, amelyre lépésérték segítségével lehet iterálni.

4. Gyűjtemény ösztönzése

Elemek hozzáadása egy Tömb lista vagy HashSet, egy olyan gyűjteményt példányosítunk, hogy felhívjuk a no-arg konstruktort, majd egyesével hozzáadjuk az egyes elemeket.

Bár ezt még mindig megtehetjük az Eclipse gyűjteményekben, Gyűjteményt is példányosíthatunk, és az összes kezdeti elemet egyszerre adhatjuk meg egyetlen sorban.

Lássuk, hogyan tudjuk példányosítani a FastList:

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

Hasonlóképpen példázhatjuk a UnifiedSet és adjon hozzá elemeket az elemek továbbításával a newSetWith () statikus módszer:

Készlet-összehasonlítás = UnifiedSet.newSetWith ("Porsche", "Volkswagen", "Toyota", "Mercedes");

Így példázhatjuk a HashBag:

MutableBag táska = HashBag.newBagWith ("Porsche", "Volkswagen", "Toyota", "Porsche", "Mercedes");

A térképek beidegzése, valamint kulcs- és értékpárok hozzáadása hasonló. Az egyetlen különbség az, hogy a kulcs és érték párokat átadjuk a newMapWith () módszer a Pár felület.

Vessünk UnifiedMap mint például:

Pár1 = párok.pár (1, "egy"); Pár2 = Tollok.pár (2, "Kettő"); Páros pár3 = Tollok.pár (3, "Három"); UnifiedMap map = új UnifiedMap (pár1, pár2, pár3);

Továbbra is használhatjuk a Java Collections API megközelítést:

UnifiedMap map = új UnifiedMap (); map.put (1, "egy"); map.put (2, "kettő"); map.put (3, "három");

Mivel változhatatlan gyűjtemények nem módosíthatók, nincsenek olyan módszereik, amelyek módosítanák a gyűjteményeket mint például add () és eltávolítás ().

A módosíthatatlan gyűjtemények azonban lehetővé teszik számunkra, hogy ezeket a módszereket hívjuk, de egy UnsupportedOperationException ha megtesszük.

5. Elemek lekérése a gyűjteményekből

Csakúgy, mint a szabvány használata Listák, az Eclipse gyűjtemények elemei Listák indexük alapján lekérhetők:

list.get (0);

Az Eclipse Gyűjtemények térképeinek értékei pedig a kulcsukkal tölthetők le:

map.get (0);

A getFirst () és getLast () módszerek használhatók a lista első és utolsó elemének lekérésére. Más gyűjtemények esetén visszaadják az első és az utolsó elemet, amelyet egy iterátor adna vissza.

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

A módszerek max () és perc () felhasználható a gyűjtemény maximális és minimális értékének a természetes rendezés alapján történő megszerzéséhez.

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

6. Iterálás egy gyűjtemény felett

Az Eclipse Gyűjtemények számos módszert kínálnak a gyűjtemények ismétléséhez. Lássuk, mik ők és hogyan működnek a gyakorlatban.

6.1. Gyűjtemény szűrése

A select minta egy új gyűjteményt ad vissza, amely egy gyűjtemény olyan elemeit tartalmazza, amelyek megfelelnek egy logikai feltételnek. Lényegében szűrési művelet.

Íme egy példa:

@Test public void givenListwhenSelect_thenCorrect () {MutableList nagyobbThanThirty = list .select (Predicates.greaterThan (30)) .sortThis (); Assertions.assertThat (nagyobbThirty) .contactExactly (31, 38, 41); }

Ugyanezt meg lehet tenni egy egyszerű lambda kifejezés használatával:

return list.select (i -> i> 30) .sortThis ();

Az elutasítási minta ellentétes. Visszaadja az összes elem gyűjteményét, amelyek nem felelnek meg egy logikai feltételnek.

Lássunk egy példát:

@Test public void whenReject_thenCorrect () {MutableList notGreaterThanThirty = list .reject (Predicates.greaterThan (30)) .sortThis (); Assertions.assertThat (notGreaterThanThirty) .containsExactlyElementsOf (this.expectedList); }

Itt elutasítunk minden 30-nál nagyobb elemet.

6.2. A gyűjt() Módszer

A gyűjt A method egy új gyűjteményt ad vissza, amelynek elemei a megadott lambda kifejezés által kapott eredmények - lényegében a térkép() és gyűjt() a Stream API-ból.

Lássuk működés közben:

@Test public void whenCollect_thenCorrect () {Student student1 = new Student ("John", "Hopkins"); Student student2 = new Student ("George", "Adams"); MutableList hallgatók = FastList .newListWith (hallgató1, tanuló2); MutableList vezetéknevek = diákok .collect (Student :: getLastName); Assertions.assertThat (vezetéknevek) .conactExactly ("Hopkins", "Adams"); }

A létrehozott gyűjtemény családnevek tartalmazza a vezetékneveket, amelyeket a diákok lista.

De, Mi van akkor, ha a visszaküldött gyűjtemény egy gyűjtemény, és nem akarunk beágyazott struktúrát fenntartani?

Például, ha minden hallgatónak több címe van, és szükségünk van egy gyűjteményre, amely a címeket as névként tartalmazza Húrok Gyűjtemények gyűjteménye helyett használhatjuk a flatCollect () módszer.

Íme egy példa:

@Test public void whenFlatCollect_thenCorrect () {MutableList címek = hallgatók .flatCollect (Student :: getAddresses); Assertions.assertThat (címek) .containsExactlyElementsOf (this.expectedAddresses); }

6.3. Elemfelismerés

A felismerni A method megtalálja és visszaküldi az első elemet, amely kielégít egy logikai feltételt.

Nézzünk át egy gyors példát:

@Test public void whenDetect_thenCorrect () {Egész eredmény = list.detect (Predicates.greaterThan (30)); Állítások.assertThat (eredmény) .isEqualTo (41); }

A anySatisfy A módszer meghatározza, hogy a gyűjtemény bármely eleme megfelel-e logikai feltételnek.

Íme egy példa:

@Test public void whenAnySatisfiesCondition_thenCorrect () {logikai eredmény = list.anySatisfy (Predicates.greaterThan (30)); assertTrue (eredmény); }

Hasonlóképpen a allSatisfy A módszer meghatározza, hogy a gyűjtemény minden eleme megfelel-e egy logikai feltételnek.

Lássunk egy gyors példát:

@Test public void whenAnySatisfiesCondition_thenCorrect () {logikai eredmény = list.allSatisfy (Predicates.greaterThan (0)); assertTrue (eredmény); }

6.4. A partíció () Módszer

A partíció A módszer a gyűjtemény minden elemét két gyűjtemény egyikébe osztja el attól függően, hogy az elem megfelel-e egy logikai feltételnek.

Lássunk egy példát:

@Test public void whenAnySatisfiesCondition_thenCorrect () {MutableList numbers = list; PartitionMutableList partitionedFolks = számok .partíció (i -> i> 30); MutableList nagyobbThanThirty = partitionedFolks .getSelected () .sortThis (); MutableList smallThanThirty = partitionedFolks .getRejected () .sortThis (); Assertions.assertThat (smallThanThirty) .conactExactly (1, 5, 8, 17, 23); Assertions.assertThat (nagyobbThirty) .contactExactly (31, 38, 41); }

6.5. Lusta iteráció

A lusta iteráció egy optimalizálási mintázat, amelyben egy iterációs metódust hívnak meg, de tényleges végrehajtását elhalasztják, amíg a műveletét vagy a visszatérési értékét egy másik későbbi módszer megköveteli.

@Test public void whenLazyIteration_thenCorrect () {Student student1 = new Student ("John", "Hopkins"); Student student2 = new Student ("George", "Adams"); Student student3 = új hallgató ("Jennifer", "Rodriguez"); MutableList hallgatók = Lists.mutable .with (hallgató1, tanuló2, tanuló3); LustaIterable lazaStudents = students.asLazy (); LazyIterable vezetéknevek = lazaStudents .collect (Student :: getLastName); Assertions.assertThat (vezetéknevek) .containsAll (Lists.mutable.with ("Hopkins", "Adams", "Rodriguez")); }

Itt a lustaTanulók objektum nem tölti be a diákok listáig a gyűjt() módszert nevezzük.

7. Gyűjtési elemek párosítása

A módszer, a metódus postai irányítószám() új gyűjteményt ad vissza, két elem gyűjteményét párokba egyesítve. Ha a két gyűjtemény bármelyike ​​hosszabb, a többi elem csonkolásra kerül.

Lássuk, hogyan tudjuk használni:

@Test public void whenZip_thenCorrect () {MutableList numbers = Lists.mutable .with ("1", "2", "3", "Ignored"); MutableList cars = Lists.mutable .with ("Porsche", "Volvo", "Toyota"); MutableList párok = számok.zip (autók); Assertions.assertThat (párok) .conconExactlyElementsOf (this.expectedPairs); }

A gyűjtemény elemeit az indexeikkel is párosíthatjuk a zipWithIndex () módszer:

@Test public void whenZip_thenCorrect () {MutableList cars = FastList .newListWith ("Porsche", "Volvo", "Toyota"); MutableList párok = autók.zipWithIndex (); Assertions.assertThat (párok) .containExactlyElementsOf (this.expectedPairs); }

8. Gyűjtemények konvertálása

Az Eclipse Gyűjtemények egyszerű módszereket kínálnak a konténertípus átalakítására egy másikra. Ezek a módszerek toList (), beállít(), toag () és térképre().

Lássuk, hogyan tudjuk felhasználni őket:

public static List convertToList () {UnifiedSet cars = new UnifiedSet (); autók.add ("Toyota"); autók.add ("Mercedes"); autók.add ("Volkswagen"); vissza autók.toList (); }

Futtassuk a tesztünket:

@Test public void whenConvertContainerToAnother_thenCorrect () {MutableList cars = (MutableList) ConvertContainerToAnother .convertToList (); Assertions.assertThat (autók). TartalmazPontosanElementOf (FastList.newListWith ("Volkswagen", "Toyota", "Mercedes")); }

9. Következtetés

Ebben az oktatóanyagban rövid áttekintést láthattunk az Eclipse gyűjteményekről és az általuk nyújtott szolgáltatásokról.

Az oktatóanyag teljes megvalósítása elérhető a GitHubon.