Bevezetés a fuvarokba
1. Áttekintés
A tuple több olyan elem gyűjteménye, amelyek kapcsolatban állnak egymással vagy sem. Más szavakkal, a sorokat névtelen objektumoknak tekinthetjük.
Például a [„RAM”, 16, „Astra”] egy három elemet tartalmazó sorozat.
Ebben a cikkben gyorsan áttekintünk egy igazán egyszerű könyvtárat, amely lehetővé teszi számunkra, hogy dolgozzunk a duplalapú adatstruktúrákkal, javatuples.
2. Beépített Javatuples Osztályok
Ez a könyvtár tíz különböző osztályt biztosít számunkra, amelyek elegendőek lennének a többszörös követelményekkel:
- Mértékegység
- Pár
- Hármas
- Kvartett
- Ötös
- Szextett
- Szeptett
- Oktett
- Ennead
- Évtized
A fenti osztályok mellett két további osztály létezik, Kulcs érték és LabelValue, amelyek hasonló funkciókat biztosítanak Pár, de szemantikában különböznek egymástól.
A hivatalos webhely szerint összes osztályaA javatuples típusúak és változhatatlanok. A tuple osztályok mindegyike végrehajtja a Iterálható, Sorosítható, és Hasonló felület.
3. Maven-függőség hozzáadása
Tegyük hozzá a Maven-függőséget a sajátunkhoz pom.xml:
org.javatuples javatuples 1.2
Kérjük, ellenőrizze a legújabb verziót a Central Maven tárházban.
4. Tollok létrehozása
Tuple létrehozása nagyon egyszerű. Használhatjuk a megfelelő konstruktorokat:
Pár pár = új pár ("A pár", 55);
Van egy kicsit kevésbé bőbeszédű és szemantikailag elegáns módszer a kettő létrehozására:
Triplet triplet = Triplet.with ("hello", 23, 1.2);
Az an-ból is készíthetünk sorokat Iterálható:
List listOfNames = Arrays.asList ("john", "őz", "anne", "alex"); Kvartettkvartett = Quartet.fromCollection (collectionOfNames);
Kérjük, vegye figyelembe, hogy a gyűjteményben lévő tételek számának meg kell egyeznie a létrehozni kívánt tus típusával. Például nem hozhatunk létre a Ötös a fenti gyűjtemény felhasználásával, mivel pontosan öt elemre van szükség. Ugyanez vonatkozik minden más olyan osztályra, amelynek magasabb a rendje, mint Ötös.
Létrehozhatunk azonban egy alacsonyabb rendű duplát is Pár vagy a Hármas a fenti gyűjtemény használatával, megadva egy kezdő indexet a fromIterable () módszer:
Pair pairFromList = Pair.fromIterable (listOfNames, 2);
A fenti kód a Pár tartalmazó „anne”És„alex“.
A tömbök kényelmesen létrehozhatók bármely tömbből is:
Karakterlánc [] nevek = új karakterlánc [] {"john", "őz", "anne"}; Triplet triplet2 = Triplet.fromArray (nevek);
5. Értékek elsajátítása a gyűrűkből
Minden osztály javatuples van egy getValueX () módszer az értékek többszöröséből történő kinyerésére, ahol x meghatározza az elem sorrendjét a duplán belül. A tömbök indexeihez hasonlóan a x nulláról indul.
Hozzunk létre egy új kvartettet, és töltsünk le néhány értéket:
Kvartettkvartett = Quartet.with ("john", 72.5, 32, "1051 SW"); Karakterlánc neve = kvartett.getValue0 (); Egész életkor = kvartett.getValue2 (); assertThat (név) .isEqualTo ("john"); assertThat (kor) .isEqualTo (32);
Mint láthatjuk, a „János"Nulla,"72.5”Egy, és így tovább.
Vegye figyelembe, hogy a getValueX () módszerek típusbiztosak. Ez azt jelenti, hogy nincs szükség öntésre.
Ennek alternatívája a getValue (int pos) módszer. A beolvasandó elem nulla alapú pozícióját veszi fel. Ez a módszer nem típusbiztonságos, és kifejezett átküldést igényel:
Kvartettkvartett = Quartet.with ("john", 72.5, 32, "1051 SW"); Karakterlánc neve = (String) kvartett.getValue (0); Egész életkor = (Egész) kvartett.getValue (2); assertThat (név) .isEqualTo ("john"); assertThat (kor) .isEqualTo (32);
Felhívjuk figyelmét, hogy az osztályok Kulcs érték és LabelValue megvannak a megfelelő módszereik getKey () / getValue () és getLabel () / getValue ().
6. Értékek beállítása a halmazoknak
Hasonló getValueX (), a javatuples összes osztályának van setAtX () mód. Újra, x a beállítani kívánt elem nulla alapú pozíciói:
John pár = pár. With-el ("john", 32); Pár alex = john.setAt0 ("alex"); assertThat (john.toString ()). isNotEqualTo (alex.toString ());
A legfontosabb itt az, hogy a visszatérési típus setAtX () A módszer maga a duplatípus. Ez azért van, mert a javatuples megváltoztathatatlan. Bármely új érték beállítása az eredeti példányt érintetlenül hagyja.
7. Elemek hozzáadása és eltávolítása a halmazokból
Kényelmesen hozzáadhatunk új elemeket a sorokhoz. Ennek eredményeként egy magasabb rendű új duplát hozunk létre:
Páros pár1 = Pár.-vel ("john", 32); Triplett triplett1 = pair1.add ("1051 SW"); assertThat (triplet1.contains ("john")); assertThat (triplett1.tartalmaz (32)); assertThat (triplet1.contains ("1051 SW"));
A fenti példából egyértelmű, hogy egy elem hozzáadása az a-hoz Pár létrehoz egy új Hármas. Hasonlóképpen, egy elem hozzáadása az a-hoz Hármas létrehoz egy új Kvartett.
A fenti példa a tartalmaz () módszer az összes osztály által biztosított javatuples. Ez egy nagyon praktikus módszer annak ellenőrzésére, hogy a tuple tartalmaz-e egy adott értéket.
Az is lehetséges, hogy az egyik duplát hozzáadja a másikhoz a add () módszer:
Páros pár1 = Pár.-vel ("john", 32); Pár2 = Pár.-vel ("alex", 45); Kvartett kvartett2 = pár1.add (pár2); assertThat (kvartett2.tartalmazAll (pár1)); assertThat (kvartett2.tartalmazAll (pár2));
Vegye figyelembe a tartalmazzaAll () módszer. Visszatér igaz ha az összes elemét pár1 vannak jelen kvartett2.
Alapértelmezés szerint a add () A metódus hozzáadja az elemet a tuple utolsó elemeként. Az elem azonban hozzáadható egy adott pozícióhoz a használatával addAtX () módszer, ahol x a nulla alapú pozíció, ahová fel akarjuk venni az elemet:
Páros pár1 = Pár.-vel ("john", 32); Triplett triplett2 = pair1.addAt1 ("1051 SW"); assertThat (triplet2.indexOf ("john")). isEqualTo (0); assertThat (triplet2.indexOf ("1051 SW"). isEqualTo (1); assertThat (triplet2.indexOf (32)). isEqualTo (2);
Ez a példa hozzáadja a Húr az 1-es pozícióban, amelyet azután ellenőriz indexe() módszer. Kérjük, vegye figyelembe a különbséget a Pár és a Hármas hívása után addAt1 () módszer hívása.
Több elemet is felvehetünk bármelyik használatával add () vagy addAtX () mód:
Páros pár1 = Pár.-vel ("john", 32); Kvartett kvartett1 = pair1.add ("alex", 45); assertThat (kvartett1.tartalmazAll ("alex", "john", 32, 45));
Egy elem eltávolításához a duplából használhatjuk a removeFromX () módszer. Újra, x meghatározza az eltávolítandó elem nulla alapú helyzetét:
Páros pár1 = Pár.-vel ("john", 32); Egység egység = pair1.removeFrom0 (); assertThat (egység.tartalmaz (32));
8. A tincsek konvertálása Lista / tömb
Már láttuk, hogyan lehet a Lista egy duplának. Lássuk most forrónak, hogy átalakítsunk egy duplát a-vá Lista:
Kvartettkvartett = Quartet.with ("john", 72.5, 32, "1051 SW"); Lista lista = quartet.toList (); assertThat (list.size ()). isEqualTo (4);
Ez meglehetősen egyszerű. Itt csak annyit kell megjegyezni, hogy mindig kapunk egy Lista, még akkor is, ha a tuple azonos típusú elemeket tartalmaz.
Végül konvertáljuk a duplát tömbgé:
Kvartettkvartett = Quartet.with ("john", 72.5, 32, "1051 SW"); Object [] tömb = kvartett.toArray (); assertThat (tömb.hossz) .isEqualTo (4);
Elég világos, a array () metódus mindig egy Tárgy[].
9. Következtetés
Ebben a cikkben feltártuk a javatuples könyvtárat, és megfigyeltük annak egyszerűségét. Elegáns szemantikát nyújt és nagyon egyszerűen használható.
Győződjön meg róla, hogy megnézte a cikk teljes forráskódját a GitHubon. A teljes forráskód valamivel több példát tartalmaz, mint az itt tárgyaltak. A cikk elolvasása után a további példáknak elég könnyen érthetőnek kell lenniük.