streamalism.org

1. Overzicht

Een tuple is een verzameling van verschillende elementen die al dan niet met elkaar verband houden. Met andere woorden, tuples kunnen als anonieme objecten worden beschouwd.

["RAM", 16, "Astra"] is bijvoorbeeld een tuple met drie elementen.

In dit artikel zullen we een snelle blik werpen op een heel eenvoudige bibliotheek waarmee we kunnen werken met de op tuple gebaseerde datastructuren, genaamd javatuples.

2. Ingebouwd Javatuples Klassen

Deze bibliotheek biedt ons tien verschillende klassen die aan de meeste van onze vereisten met betrekking tot tuples zouden voldoen:

• Eenheid
• Paar
• Triplet
• Kwartet
• Kwintet
• Sextet
• Septet
• Octet
• Ennead
• Decennium

Naast de bovenstaande lessen zijn er twee extra lessen, Sleutel waarde en LabelValue, die functionaliteiten bieden die vergelijkbaar zijn met Paar, maar verschillen in semantiek.

Volgens de officiële site, alle klassen injavatuples zijn typeveilig en onveranderlijk. Elk van de tuple-klassen implementeert de Herhaalbaar, Serialiseerbaar, en Vergelijkbaar koppel.

3. Maven-afhankelijkheid toevoegen

Laten we de Maven-afhankelijkheid toevoegen aan onze pom.xml:

 org.javatuples javatuples 1.2 

Controleer de Central Maven-repository voor de nieuwste versie.

4. Tuples maken

Het maken van een tuple is heel eenvoudig. We kunnen de bijbehorende constructors gebruiken:

Paar paar = nieuw paar ("A-paar", 55);

Er is ook een iets minder uitgebreide en semantisch elegante manier om een ​​tuple te maken:

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

We kunnen ook tuples maken van een Herhaalbaar:

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

Houd er rekening mee dat het aantal items in de verzameling moet overeenkomen met het type tupel dat we willen maken. We kunnen bijvoorbeeld geen Kwintet gebruikmakend van de bovenstaande collectie, omdat het precies vijf elementen vereist. Hetzelfde geldt voor elke andere tuple-klasse met een hogere volgorde dan Kwintet.

We kunnen echter een tupel van een lagere orde maken, zoals Paar of een Triplet met behulp van de bovenstaande verzameling, door een startindex op te geven in de fromIterable () methode:

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

De bovenstaande code resulteert in het maken van een Paar met "anne"En"Alex“.

Tuples kunnen ook gemakkelijk vanuit elke array worden gemaakt:

String [] namen = nieuwe String [] {"john", "doe", "anne"}; Triplet triplet2 = Triplet.fromArray (namen);

5. Waarden krijgen van Tuples

Elke klas in javatuples heeft een getValueX () methode voor het ophalen van de waarden van tuples, where X specificeert de volgorde van het element in het tupel. Net als de indexen in arrays is de waarde van X begint vanaf nul.

Laten we een nieuw kwartet maken en enkele waarden ophalen:

Quartet quartet = Quartet.with ("john", 72.5, 32, "1051 SW"); String naam = kwartet.getValue0 (); Geheel getal leeftijd = kwartet.getValue2 (); assertThat (naam) .isEqualTo ("john"); assertThat (leeftijd) .isEqualTo (32);

Zoals we kunnen zien, is de positie van "John"Is nul,"72.5”Is er een, enzovoort.

Merk op dat de getValueX () methoden zijn type-safe. Dat betekent dat gieten niet nodig is.

Een alternatief hiervoor is de getValue (int pos) methode. Het vereist een op nul gebaseerde positie van het element dat moet worden opgehaald. Deze methode is niet type-safe en vereist expliciet casten:

Quartet quartet = Quartet.with ("john", 72.5, 32, "1051 SW"); String naam = (String) quartet.getValue (0); Geheel getal leeftijd = (Geheel getal) quartet.getValue (2); assertThat (naam) .isEqualTo ("john"); assertThat (leeftijd) .isEqualTo (32);

Houd er rekening mee dat de lessen Sleutel waarde en LabelValue hebben hun overeenkomstige methoden getKey () / getValue () en getLabel () / getValue ().

6. Waarden instellen voor Tuples

Gelijkwaardig aan getValueX (), alle klassen in javatuples hebben setAtX () methoden. Opnieuw, X is op nul gebaseerde posities voor het element dat we willen instellen:

Pair john = Pair.with ("john", 32); Paar alex = john.setAt0 ("alex"); assertThat (john.toString ()). isNotEqualTo (alex.toString ());

Het belangrijkste hierbij is dat het retourtype van setAtX () methode is het tuple-type zelf. Dit is zo omdat de javatuples zijn onveranderlijk. Als u een nieuwe waarde instelt, blijft de oorspronkelijke instantie intact.

7. Elementen toevoegen aan en verwijderen uit Tuples

We kunnen gemakkelijk nieuwe elementen aan de tuples toevoegen. Dit zal er echter toe leiden dat er een nieuwe tuple van een hogere orde wordt aangemaakt:

Paar paar1 = paar.met ("john", 32); Triplet triplet1 = pair1.add ("1051 SW"); assertThat (triplet1.contains ("john")); assertThat (triplet1.contains (32)); assertThat (triplet1.contains ("1051 SW"));

Uit het bovenstaande voorbeeld blijkt duidelijk dat het toevoegen van één element aan een Paar zal een nieuw Triplet. Evenzo voegt u één element toe aan een Triplet zal een nieuw Kwartet.

Het bovenstaande voorbeeld toont ook het gebruik van bevat () methode die door alle klassen in javatuples. Dit is een erg handige methode om te controleren of de tuple een bepaalde waarde bevat.

Het is ook mogelijk om het ene tupel aan het andere toe te voegen met de toevoegen() methode:

Paar paar1 = paar.met ("john", 32); Paar paar2 = Paar.met ("alex", 45); Kwartet kwartet2 = paar1.add (paar2); assertThat (kwartet2.containsAll (paar1)); assertThat (kwartet2.containsAll (paar2));

Let op het gebruik van bevatAll () methode. Het zal terugkeren waar als alle elementen van paar1 zijn aanwezig in kwartet2.

Standaard is het toevoegen() methode voegt het element toe als laatste element van het tupel. Het is echter mogelijk om het element op een bepaalde positie toe te voegen met addAtX () methode, waar X is de op nul gebaseerde positie waar we het element willen toevoegen:

Paar paar1 = paar.met ("john", 32); Triplet triplet2 = pair1.addAt1 ("1051 SW"); assertThat (triplet2.indexOf ("john")). isEqualTo (0); assertThat (triplet2.indexOf ("1051 SW")). isEqualTo (1); assertThat (triplet2.indexOf (32)). isEqualTo (2);

Dit voorbeeld voegt de Draad op positie 1, die vervolgens wordt geverifieerd door de index van() methode. Let op het verschil in de volgorde van de typen voor de Paar en de Triplet na de oproep naar addAt1 () methode oproep.

We kunnen ook meerdere elementen toevoegen met een van toevoegen() of addAtX () methoden:

Paar paar1 = paar.met ("john", 32); Kwartet kwartet1 = paar1.add ("alex", 45); assertThat (kwartet1.containsAll ("alex", "john", 32, 45));

Om een ​​element uit het tupel te verwijderen, kunnen we de removeFromX () methode. Opnieuw, X specificeert de op nul gebaseerde positie van het te verwijderen element:

Paar paar1 = paar.met ("john", 32); Eenheidseenheid = pair1.removeFrom0 (); assertThat (unit.contains (32));

8. Tuples converteren naar Lijst / matrix

We hebben al gezien hoe je een Lijst tot een tupel. Laten we nu eens kijken hoe heet het is om een ​​tuple om te zetten in een Lijst:

Quartet quartet = Quartet.with ("john", 72.5, 32, "1051 SW"); Lijst lijst = kwartet.toList (); assertThat (list.size ()). isEqualTo (4);

Het is vrij eenvoudig. Het enige dat hier moet worden opgemerkt, is dat we altijd een Lijst, zelfs als het tupel hetzelfde type elementen bevat.

Laten we tot slot de tuple naar een array converteren:

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

Duidelijk genoeg, de toArray () methode retourneert altijd een Voorwerp[].

9. Conclusie

In dit artikel hebben we de javatuples-bibliotheek verkend en de eenvoud ervan waargenomen. Het biedt een elegante semantiek en is heel gemakkelijk te gebruiken.

Zorg ervoor dat je de volledige broncode voor dit artikel op GitHub leest. De volledige broncode bevat iets meer voorbeelden dan degene die hier worden behandeld. Na het lezen van dit artikel zouden de aanvullende voorbeelden gemakkelijk genoeg moeten zijn om te begrijpen.