TechCodeview

A tupel is een datastructuur die objecten van verschillende typen kan bevatten. Deze objecten zijn niet met elkaar verbonden, maar hebben betekenis als we ze gezamenlijk beschouwen. In deze sectie bespreken we wat is tupel , kenmerken, grootte, En activiteiten van tupels. Ook zullen we het hebben over de tuple-implementatie in Java .

Wat is een tupel?

Over het algemeen is een tupel is een geordende verzameling objecten. In tuple worden gegevens opgeslagen als een object in een aparte byte-array. Het bevat door komma's gescheiden waarden tussen vierkante haakjes []. Tupels zijn onveranderlijk, in tegenstelling tot de gegevensstructuur van Lijsten. Een tupel kan meerdere tupels bevatten. Het kan ook als een anoniem object worden beschouwd.

Kenmerken van Tuple

Tuple heeft de volgende kenmerken:

• Het is typesafe, itereerbaar, onveranderlijk, En serialiseerbaar .
• Het implementeert de toString(), is gelijk aan(), En de hashcode()
• Het implementeert ook de Vergelijkbaar (Tuple-werktuigen vergelijkbaar)

Tupel voorbeeld

Laten we het volgende voorbeeld bekijken.

 ['Sophia', 'Female', 22, 'Marketing Manager'] 

Het bovenstaande tupel is a kwartet tweevoudig omdat het zo is vier elementen (objecten). We zien dat elk object van een ander type is. Maar als we het collectief beschouwen, heeft het een specifieke betekenis. Het bovenstaande tupel vertegenwoordigt de gegevens van een werknemer, zoals naam, geslacht, leeftijd en functie.

Laten we enkele andere voorbeelden van tupels bekijken.

 ['Java', 'Object-oriented', 14] ['John', 'Wick' 21, 'USA', false, '[email protected]'] [3, 'Samsung', 'Galaxy S2', 37000.00] 

Tupel op Java

In Java is een tupel een generieke gegevensstructuur die elk element als een object behandelt, en deze objecten worden opgeslagen in een afzonderlijke byte-array. Met andere woorden, we kunnen ook zeggen dat tuple een is besteld verzameling objecten van verschillende typen.

De functionaliteit van een tuple kan worden geïmplementeerd met behulp van de List- en Array-datastructuur, maar deze datastructuren bevatten niet per definitie verschillende soorten datatypen. Het is dus duidelijk dat heterogeen tuple met behulp van een standaard datastructuur (List/Array) is niet mogelijk in Java. Omdat we dat nodig hadden tupel gegevensstructuur om aan de eis van bezit te voldoen homogeen data structuur.

Let daar op tupel-datastructuur is niet aanwezig in Java-programmering , standaard. Maar we kunnen de tuple-gegevensstructuur implementeren door de genoemde bibliotheek van derden te gebruiken javatuples .

Voordat we naar de implementatie gaan, downloaden we eerst het javatuples.jar bestand. En voeg dit bestand toe aan het pad van het project.

We kunnen ook de volgende afhankelijkheid gebruiken in pom.xml -bestand om de tuples-gegevensstructuur in Java te implementeren.

 org.javatuples javatuples 1.2 

Laten we een tupel implementeren en een eenvoudig Java-tupelprogramma maken.

Javatuples-bibliotheek

De javatuples bibliotheek heeft de tuple-klassen die overeenkomen met de grootte van een tuple. Tuples kunnen verschillend van formaat zijn. Een tupel kan maximaal 10 elementen. De implementatie van elke tupel is anders. De klassenhiërarchie is als volgt.

 Java.lang.Object ↳ org.javatuples.Tuple ↳ org.javatuples.ClassName 

Java Tuple-klasse

De Tupel is een abstracte basisklasse voor alle tuple-klassen waartoe behoort org.javatuples pakket. Alle methoden van de tuple-klasse zijn openbaar en definitief. De volgende tabel geeft een overzicht van de methoden van de tuple-klasse. Het implementeert itereerbare en serialiseerbare interfaces.

Direct bekende subklassen

Naast de bovenstaande klassen zijn er twee extra klassen die worden aangeboden door de javatuples-bibliotheek, d.w.z. Sleutel waarde En LabelWaarde . Deze twee klassen zijn vergelijkbaar met de Paar klasse en bieden dezelfde functionaliteit, maar in verschillende semantiek.

geheel getal naar tekenreeks Java

Elke tuple-klasse implementeert de volgende drie interfaces:

• Itereerbaar
• Vergelijkbaar
• Serialiseerbaar

Implementatie van Tuple

De implementatie van een tupel in Java is heel eenvoudig. We moeten een instantie van de tuple-klasse maken die overeenkomt met de grootte.

TupleExample.java

 import org.javatuples.Quartet; public class TupleExample { public static void main(String args[]) { //create a pair tuple from the constructor Quartet quartet = new Quartet('Sophia', 'Female', 22, 'Marketing Manager'); //print the tuples objects System.out.println('The details of the employee are: ' + quartet); } } 

Uitgang:

 The details of the employee are: [Sophia, Female, 22, Marketing Manager] 

Tuple-bewerkingen

De volgende bewerkingen kunnen op een tupel worden uitgevoerd:

• Een tupel maken
• Waarden verkrijgen
• Waarden instellen
• Elementen toevoegen
• Herhaal Tuple
• Converteer Tuple naar Lijst
• Zoeken in Tupel

Tupel maken

Er zijn drie manieren om een ​​tuple te maken:

• Door de methode with() te gebruiken
• Door Constructor te gebruiken
• Door gebruik te maken van verzameling

Laten we de drie bovenstaande manieren bekijken om een ​​tupel te maken.

Door de methode with() te gebruiken

De javatuples-bibliotheek biedt de met() methode die een tuple creëert met de opgegeven waarden. De methode behoort tot de org.javatuples.Pair pakket. Het wordt gebruikt om objecten met waarden te instantiëren.

Syntaxis:

 ClassName object = ClassName.with(value-1, value-2, ......, value-n); 

Voorbeeld:

 Pair pair = Pair.with('iPhone 12', 112000.00); 

Het bovenstaande Pair-klasseobject creëert een tupel met twee waarden. Laten we hiervoor een Java-programma maken.

CreateTupleExample1.java

 import org.javatuples.Pair; class CreateTupleExample1 { public static void main(String args[]) { Pair pair = Pair.with(9086651, 'Dell Laptop'); System.out.println(pair); } } 

Uitgang:

 [9086651, Dell Laptop] 

Door Constructor te gebruiken

In dit geval maken we, afhankelijk van de vereiste, een constructor van de klasse.

Syntaxis:

 ClassName object = new ClassName (value-1, value-2, ……., value-n); 

Voorbeeld:

 Quintet quintet = new Quintet (91237, 'Mac Book Air', 88490.00, '8-Core CPU', 4); 

Laten we een Java-programma maken om een ​​tuple te maken met behulp van de constructor.

CreateTupleExample2.java

 import org.javatuples.Quintet; class CreateTupleExample1 { public static void main(String args[]) { Quintet quintet = new Quintet (91237, 'Mac Book Air', 88490.00, '8-Core CPU', 4); System.out.println(quintet); } } 

Uitgang:

 [91237, Mac Book Air, 88490.0, 8-Core CPU, 4] 

Door gebruik te maken van verzameling

Met de javatuples-bibliotheek kunnen we een tupel uit de verzameling maken met behulp van de uitVerzameling() methode. Het stelt ons ook in staat om een ​​tuple van een array te maken met behulp van de vanArray() methode. Houd er rekening mee dat de verzameling/array hetzelfde type en dezelfde waarden moet hebben als de tupel.

De collectie/array moet van hetzelfde type zijn als de Tuple en het aantal waarden in de collectie/array moet overeenkomen met de klasse Tuple.

Syntaxis:

 ClassName object = ClassName.fromCollection(list); ClassName object = ClassName.fromArray(array); 

Voorbeeld:

iPhone-emoji's op Android

 Octet p1 = Octet.fromCollection(list); Sextet p2 = Sextet.fromArray(arr); 

CreateTupleExample3.java

 import java.util.ArrayList; import java.util.List; import org.javatuples.Sextet; import org.javatuples.Octet; class CreateTupleExample3 { public static void main(String args[]) { //creating a list List list = new ArrayList(); //adding elements to the list list.add('C'); list.add('C++'); list.add('Java'); list.add('Python'); list.add('Scala'); list.add('Ruby'); list.add('PHP'); list.add('COBOL'); //creating an object of Pair class and passing the list Octet p1 = Octet.fromCollection(list); //creating an Array String[] arr = {'One', 'Two', 'Three', 'Four', 'Five', 'Six'}; //creating an object of the Pair class and invoking the fromArray() method Sextet p2 = Sextet.fromArray(arr); //prints the tuple created using list System.out.println(p1); //prints the tuple using Array System.out.println(p2); } } 

Uitgang:

 [C, C++, Java, Python, Scala, Ruby, PHP, COBOL] [One, Two, Three, Four, Five, Six] 

Waarden ophalen

Met de javatuples-bibliotheek kunnen we ook waarden ophalen uit de tupel bij de opgegeven index met behulp van de getWaardeX() methode. Waarbij X de indexwaarde van het object aangeeft. Het indexeren begint vanaf 0.

Voorbeeld:

 Pair pair = new Pair(value-1, value-2); type1 val1 = pair.getValue0(); 

GetValueExample.java

 import org.javatuples.Pair; class GetTupleValue { public static void main(String args[]) { //creating a tuple Pair pair = Pair.with(12, 'Andrew'); //getting values at index 1 System.out.println(pair.getValue1()); } } 

Uitgang:

 [Andrew] 

Waarden instellen

Zoals we hierboven hebben besproken, zijn tupels onveranderlijk. Daarom kunnen ze niet meer worden gewijzigd nadat ze zijn gemaakt. Om dit probleem op te lossen, biedt de javatuples-bibliotheek de setWaardeX() methode. Waarbij X de indexwaarde is waarop we de specifieke waarde willen instellen. De methode maakt een kopie van de tupel met de nieuw toegevoegde waarde bij de opgegeven index en retourneert dezelfde tupel.

Voorbeeld:

 Pair pair = new Pair(value-1, value-2); type1 val1 = pair.getValue0(); 

SetValueExample.java

 import org.javatuples.Pair; class SetTupleValue { public static void main(String args[]) { //creating a tuple Pair p1 = Pair.with(67, 69); //setting tuple value at index 1 Pair p2 = p1.setAt1(68); System.out.println(p2); } } 

Uitgang:

 [67, 68] 

Een waarde toevoegen

Er zijn twee manieren om waarden toe te voegen aan een tupel:

• Aan het einde van de tupel
• Bij specifieke Index

Aan het einde van de Tuple

De javatuples-bibliotheek biedt de toevoegen() methode om objecten aan de tuple toe te voegen. Het voegt het object toe aan het einde van het tupel en retourneert een nieuw tupel door het aantal elementen te matchen.

Stel dat we een tupel hebben met twee elementen en we willen nog een element aan de tupel toevoegen. In een dergelijk geval ondersteunt het Paar-tupel het derde element niet. Wanneer we een element aan een paar-tupel toevoegen, wordt het daarom omgezet in een triplet-tupel. Laten we een voorbeeld bekijken.

AddElementInTuple.java

 import org.javatuples.Pair; import org.javatuples.Triplet; public class AddElementInTuple { public static void main(String args[]) { Pair pair = Pair.with('Jack', 46); Triplet triplet = pair.add('Finance Professional'); System.out.println(pair); System.out.println(triplet); } } 

Uitgang:

 [Jack, 46] [Jack, 46, Finance Professional] 

We kunnen ook een tupel aan een andere tupel toevoegen. Het verhoogt het aantal elementen in de nieuw gegenereerde tuple. Daarom retourneert het het type tupel op basis van het aantal elementen dat aanwezig is na toevoeging.

AddTuplesExample.java

 import org.javatuples.Quartet; import org.javatuples.Septet; import org.javatuples.Triplet; public class AddTuplesExample { public static void main(String args[]) { //creating a tuple with three elements Triplet triplet = Triplet.with('Mango', 'Grapes', 'Papaya'); //creating an object of quartet tuple and adding an elements at index-1 in triplet tuple Quartet quartet = triplet.addAt1('Banana'); //adding quartet and triplet tuple we get a septet tuple i.e. 3+4=7 //the following statement can be written as Septet septet = quartet.add(triplet); Septet septet = quartet.add(triplet); System.out.println(triplet); System.out.println(quartet); System.out.println(septet); } } 

Uitgang:

 [Mango, Grapes, Papaya] [Mango, Banana, Grapes, Papaya] [Mango, Banana, Grapes, Papaya, Mango, Grapes, Papaya] 

Bij gespecificeerde index

Standaard worden nieuwe elementen toegevoegd aan het einde van de tuple. Maar we kunnen elementen aan de opgegeven index toevoegen door de voegX() toe methode.

AddAtIndexExample.java

 import org.javatuples.Quartet; import org.javatuples.Triplet; public class AddAtIndexExample { public static void main(String args[]) { //creating a tuple with three elements Triplet triplet = Triplet.with('MCA', 'M.Sc.', 'MBBS'); //creating an object of quartet tuple and adding an element at index-2 in triplet tuple Quartet quartet = triplet.addAt2('M.Tech'); System.out.println(triplet); System.out.println(quartet); } } 

Uitgang:

 [MCA, M.Sc., MBBS] [MCA, M.Sc., M.Tech, MBBS] 

Een element zoeken

We kunnen ook zoeken naar een element dat zich in de tupel bevindt. Voor het zoeken naar javatuples biedt de bibliotheek de bevat() methode van de Tuple-klasse. Het retourneert een Booleaanse waarde WAAR als een element aanwezig is, keert else terug vals . Laten we een voorbeeld bekijken.

SearchElementExample.java

 import org.javatuples.Pair; class SearchingElementExample { public static void main(String args[]) { Pair pair = Pair.with(34, 'Jack'); //returns true because Jack is present in tuple boolean res1 = pair.contains('Jack'); //returns false because Andrew is not present in tuple boolean res2 = pair.contains('Andrew'); System.out.println(res1); System.out.println(res2); } } 

Uitgang:

 true false 

Converteer Tuple naar verzameling of array

Elke tuple-klasse heeft de methoden asList() en toArray() die respectievelijk List en Array retourneren. Laten we een voorbeeld bekijken.

TupleToCollection.java

 import java.util.Arrays; import java.util.List; import org.javatuples.Quartet; public class TupleToCollection { public static void main(String args[]) { //Convert to list Quartet quartet = Quartet.with('Dog', 12,'German Shepherd', 23.89); //converts to list List list = quartet.toList(); //prints list System.out.println(list); //Converts to array Object[] quartletArr = quartet.toArray(); //prints array System.out.println(Arrays.toString(quartletArr)); } } 

Uitgang:

 [Dog, 12, German Shepherd, 23.89] [Dog, 12, German Shepherd, 23.89] 

Houd er rekening mee dat tuple heterogene typen kan bevatten, dus het resulterende type zal van zijn Lijst of Voorwerp[] overeenkomstig.

shellscript uitvoerbaar maken

Iteratie over Tuple

Alle tuple-klassen implementeren de Itereerbaar koppel. We kunnen een tupel dus op dezelfde manier herhalen als verzamelingen of arrays.

IterateTuple.java

 import org.javatuples.Quartet; class IterateTuple { public static void main(String args[]) { //creating a quartet tuple Quartet quartet = Quartet.with('Dell', 5600.00, 34, 'Digital Solutions'); //iterate over tuple for(Object obj : quartet) { //prints elements System.out.println(obj); } } } 

Uitgang:

 Dell 5600.0 34 Digital Solutions 

Tuple versus. Lijst/matrix