Introduktion til Javatuples

1. Oversigt

En tuple er en samling af flere elementer, der måske eller ikke er relateret til hinanden. Med andre ord kan tupler betragtes som anonyme objekter.

For eksempel er ["RAM", 16, "Astra"] en tuple, der indeholder tre elementer.

I denne artikel vil vi hurtigt se på et virkelig simpelt bibliotek, der giver os mulighed for at arbejde med de tuplebaserede datastrukturer, navngivet javatuples.

2. Indbygget Javatuples Klasser

Dette bibliotek giver os ti forskellige klasser, der er tilstrækkelige for de fleste af vores krav til tupler:

  • Enhed
  • Par
  • Triplet
  • Kvartet
  • Kvintet
  • Sekstet
  • Septet
  • Octet
  • Ennead
  • Årti

Ud over klasserne ovenfor er der to ekstra klasser, KeyValue og LabelValue, som giver funktioner svarende til Par, men adskiller sig i semantik.

I henhold til det officielle websted, alle klasser ijavatuples er typesafe og uforanderlige. Hver af tupleklassen implementerer Iterabel, Serialiserbarog Sammenlignelig interface.

3. Tilføjelse af Maven-afhængighed

Lad os tilføje Maven-afhængigheden til vores pom.xml:

 org.javatuples javatuples 1.2 

Se Central Maven-arkivet for den nyeste version.

4. Oprettelse af tuples

At skabe en tuple er virkelig enkel. Vi kan bruge de tilsvarende konstruktører:

Parpar = nyt par ("Et par", 55);

Der er også en lidt mindre detaljeret og semantisk elegant måde at skabe en tuple på:

Triplet triplet = Triplet.with ("hej", 23, 1.2);

Vi kan også skabe tupler fra en Iterabel:

List listOfNames = Arrays.asList ("john", "doe", "anne", "alex"); Kvartetkvartet = Quartet.fromCollection (collectionOfNames);

Bemærk, at antallet af genstande i samlingen skal matche den type tuple, vi vil oprette. For eksempel kan vi ikke oprette en Kvintet ved hjælp af ovenstående samling, da det kræver nøjagtigt fem elementer. Det samme gælder for enhver anden tupleklasse, der har en højere orden end Kvintet.

Vi kan dog oprette en tuple med lavere ordre som Par eller a Triplet ved hjælp af ovenstående samling ved at angive et startindeks i fraIterable () metode:

Pair pairFromList = Pair.fromIterable (listOfNames, 2);

Ovenstående kode vil resultere i oprettelse af en Par indeholdende “anne”Og“alex“.

Tuples kan også nemt oprettes fra ethvert array:

String [] names = new String [] {"john", "doe", "anne"}; Triplet triplet2 = Triplet.fromArray (navne);

5. Få værdier fra tupler

Hver klasse i javatuples har en getValueX () metode til at hente værdierne fra tupler, hvor x specificerer rækkefølgen af ​​elementet inde i tuplen. Ligesom indekserne i arrays, værdien af x starter fra nul.

Lad os oprette en ny kvartet og hente nogle værdier:

Kvartetkvartet = Quartet.with ("john", 72.5, 32, "1051 SW"); String name = quartet.getValue0 (); Heltalder = kvartet.getValue2 (); assertThat (name) .isEqualTo ("john"); hævder, at (alder) .isEqualTo (32);

Som vi kan se, er “John”Er nul,“72.5”Er en og så videre.

Bemærk, at getValueX () metoder er typesikre. Det betyder, at der ikke kræves nogen støbning.

Et alternativ til dette er getValue (int pos) metode. Det tager en nulbaseret position af det element, der skal hentes. Denne metode er ikke typesikker og kræver eksplicit casting:

Kvartetkvartet = Quartet.with ("john", 72.5, 32, "1051 SW"); String name = (String) quartet.getValue (0); Heltalder = (Heltal) kvartet.getValue (2); assertThat (name) .isEqualTo ("john"); hævder, at (alder) .isEqualTo (32);

Bemærk, at undervisningen KeyValue og LabelValue har deres tilsvarende metoder getKey () / getValue () og getLabel () / getValue ().

6. Indstilling af værdier til tupler

Svarende til getValueX (), alle klasser i javatuples har setAtX () metoder. Igen, x er nulbaserede positioner for det element, som vi vil indstille:

Par john = Pair.with ("john", 32); Par alex = john.setAt0 ("alex"); assertThat (john.toString ()). erNotEqualTo (alex.toString ());

Det vigtige her er, at returneringstypen af setAtX () metoden er selve tupletypen. Dette er fordi javatuples er uforanderlige. Hvis du indstiller en ny værdi, forbliver den oprindelige forekomst intakt.

7. Tilføjelse og fjernelse af elementer fra tupler

Vi kan nemt tilføje nye elementer til tuplerne. Dette vil dog resultere i, at der oprettes en ny tuple med en højere orden:

Par par1 = Par.med ("john", 32); Triplet triplet1 = pair1.add ("1051 SW"); assertThat (triplet1.contains ("john")); assertThat (triplet1.contains (32)); assertThat (triplet1.contains ("1051 SW"));

Det fremgår klart af ovenstående eksempel, at tilføjelse af et element til a Par vil skabe et nyt Triplet. Tilsvarende tilføjer et element til en Triplet vil skabe et nyt Kvartet.

Eksemplet ovenfor viser også brugen af indeholder() metode leveret af alle klasser i javatuples. Dette er en virkelig praktisk metode til at kontrollere, om tuplen indeholder en given værdi.

Det er også muligt at tilføje en tuple til en anden ved hjælp af tilføje() metode:

Par par1 = Par.med ("john", 32); Par par2 = Par.med ("alex", 45); Kvartet kvartet2 = pair1.add (pair2); assertThat (quartet2.containsAll (pair1)); assertThat (quartet2.containsAll (pair2));

Bemærk brugen af indeholderAlle () metode. Det vender tilbage rigtigt hvis alle elementerne i par1 er til stede i kvartet2.

Som standard er tilføje() metoden tilføjer elementet som et sidste element i tuplen. Det er dog muligt at tilføje elementet ved en given position ved hjælp af addAtX () metode, hvor x er den nulbaserede position, hvor vi vil tilføje elementet:

Par par1 = Par.med ("john", 32); Triplet triplet2 = pair1.addAt1 ("1051 SW"); assertThat (triplet2.indexOf ("john")). er EqualTo (0); assertThat (triplet2.indexOf ("1051 SW")) er EqualTo (1); assertThat (triplet2.indexOf (32)). er EqualTo (2);

Dette eksempel tilføjer Snor i position 1, som derefter bekræftes af indeks af() metode. Bemærk forskellen i rækkefølgen af ​​typerne til Par og Triplet efter opkaldet til addAt1 () metodeopkald.

Vi kan også tilføje flere elementer ved hjælp af et af tilføje() eller addAtX () metoder:

Par par1 = Par.med ("john", 32); Kvartetkvartet1 = pair1.add ("alex", 45); assertThat (kvartet1.containsAll ("alex", "john", 32, 45));

For at fjerne et element fra tuplen kan vi bruge removeFromX () metode. Igen, x angiver den nulbaserede position for det element, der skal fjernes:

Par par1 = Par.med ("john", 32); Enhedsenhed = pair1.removeFrom0 (); assertThat (unit.contains (32));

8. Konvertering af tuples til Liste / matrix

Vi har allerede set, hvordan man konverterer en Liste til en tuple. Lad os nu se varmt for at konvertere en tuple til en Liste:

Kvartetkvartet = Quartet.with ("john", 72.5, 32, "1051 SW"); Liste liste = kvartet.toListe (); assertThat (list.size ()). er EqualTo (4);

Det er ret simpelt. Den eneste ting at bemærke her er, at vi altid får en Liste, selvom tuplen indeholder den samme type elementer.

Lad os endelig konvertere tuplen til en matrix:

Kvartetkvartet = Quartet.with ("john", 72.5, 32, "1051 SW"); Objekt [] array = quartet.toArray (); assertThat (array.length) .isEqualTo (4);

Klart nok, den toArray () metode returnerer altid en Objekt[].

9. Konklusion

I denne artikel har vi udforsket javatuples-biblioteket og observeret dets enkelhed. Det giver elegant semantik og er virkelig nem at bruge.

Sørg for at tjekke den komplette kildekode til denne artikel på GitHub. Den komplette kildekode indeholder lidt flere eksempler end dem, der er beskrevet her. Efter at have læst denne artikel skal de ekstra eksempler være lette nok til at forstå.