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.