TechCodeview

EN tupel er en datastruktur, der kan indeholde objekter af forskellige typer. Disse objekter er ikke forbundet med hinanden, men har betydning, når vi betragter dem samlet. I dette afsnit diskuterer vi hvad er tuple , funktioner, størrelse, og operationer af tupler. Vi vil også diskutere tuple implementering i Java .

Hvad er en tupel?

Generelt, a tupel er en ordnet samling af genstande. I tuple lagres data som et objekt i et separat byte-array. Den har kommaseparerede værdier omgivet af et par firkantede parenteser []. Tuples er uforanderlig, i modsætning til Lists datastruktur. En tuple kan rumme flere tupler. Det kan også betragtes som et anonymt objekt.

Funktioner af Tuple

Tuple har følgende funktioner:

• det er typesikker, gentagelig, uforanderlig, og kan serialiseres .
• Den implementerer toString(), er lig med(), og hashkoden()
• Det implementerer også Sammenlignelig (Tuple redskaber sammenlignelige)

Tuple eksempel

Lad os overveje følgende eksempel.

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

Ovenstående tuple er en kvartet tuple, fordi den har fire elementer (objekter). Vi observerer, at hvert objekt er af forskellig type. Men når vi betragter det samlet, har det en bestemt betydning. Ovenstående tuple repræsenterer en medarbejders data såsom navn, køn, alder og betegnelse.

Lad os se nogle andre eksempler på tupler.

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

Tuple i Java

I Java er en tuple en generisk datastruktur, der behandler hvert element som et objekt, og disse objekter lagres i et separat byte-array. Med andre ord kan vi også sige, at tuple er en bestilt samling af genstande af forskellige typer.

Funktionaliteten af ​​en tuple kan implementeres ved hjælp af List- og Array-datastrukturen, men disse datastrukturer indeholder ikke forskellige typer datatyper ved design. Derfor er det klart, at heterogen tuple ved hjælp af en standard datastruktur (List/Array) er ikke mulig i Java. Da vi krævede tupel datastruktur for at opfylde kravet om besiddelse homogen datastruktur.

Noter det tuple datastruktur er ikke til stede i Java-programmering , som standard. Men vi kan implementere tuple-datastrukturen ved at bruge det navngivne tredjepartsbibliotek javatuples .

Før vi går videre til implementeringen, downloader vi først javatuples.jar fil. Og føj denne fil til stien til projektet.

Vi kan også bruge følgende afhængighed i pom.xml fil for at implementere tuples datastruktur i Java.

 org.javatuples javatuples 1.2 

Lad os implementere en tuple og skabe et simpelt Java tuple-program.

Javatuples bibliotek

Det javatuples biblioteket har de tupelklasser, der svarer til størrelsen på en tupel. Tuples kan være forskellige i størrelse. En tupel må højst rumme 10 elementer. Implementeringen af ​​hver tuple er forskellig. Klassehierarkiet er som følger.

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

Java Tuple klasse

Det Tuple er en abstrakt basisklasse for alle de tupelklasser, der hører til org.javatuples pakke. Alle tuple-klassens metoder er offentlige og endelige. Følgende tabel opsummerer tupleklassens metoder. Det implementerer Iterable og Serialiserbare grænseflader.

Direkte kendte underklasser

Udover ovenstående klasser er der to ekstra klasser leveret af javatuples bibliotek, dvs. Nøgleværdi og LabelValue . Disse to klasser ligner Par klasse og giver den samme funktionalitet, men i forskellig semantik.

Hver tuple-klasse implementerer følgende tre grænseflader:

• Iterable
• Sammenlignelig
• Serialiserbar

Implementering af Tuple

Implementeringen af ​​en tuple i Java er meget let. Vi er nødt til at oprette en instans af tuple klasse, der svarer til størrelse.

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); } } 

Produktion:

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

Tuple Operationer

Følgende operationer kan udføres på en tupel:

• Oprettelse af en Tuple
• Få værdier
• Indstilling af værdier
• Tilføjelse af elementer
• Iterér over Tuple
• Konverter Tuple til List
• Søger i Tuple

Oprettelse af Tuple

Der er tre måder at oprette en tuple på:

• Ved at bruge with() metoden
• Ved at bruge Constructor
• Ved at bruge Samling

Lad os se ovenstående tre måder at skabe en tuple på.

Ved at bruge with() metoden

Javatuples-biblioteket giver med() metode, der opretter en tuple med de angivne værdier. Metoden tilhører org.javatuples.Pair pakke. Det bruges til at instansiere objekter med værdier.

Syntaks:

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

Eksempel:

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

Ovenstående Pair-klasseobjekt opretter en tupel med to værdier. Lad os lave et Java-program til det samme.

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); } } 

Produktion:

 [9086651, Dell Laptop] 

Ved at bruge Constructor

I dette tilfælde opretter vi en konstruktør af klassen i henhold til kravet.

Syntaks:

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

Eksempel:

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

Lad os oprette et Java-program til at skabe en tuple ved hjælp af 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); } } 

Produktion:

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

Ved at bruge Samling

Javatuples-biblioteket giver os mulighed for at skabe en tuple fra samlingen ved at bruge fromCollection() metode. Det giver os også mulighed for at skabe en tuple fra et array ved at bruge fromArray() metode. Bemærk, at samlingen/arrayet skal have samme type og værdier som tuple.

Samlingen/arrayet skal have samme type som Tuple, og antallet af værdier i samlingen/arrayet skal matche Tuple-klassen.

Syntaks:

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

Eksempel:

 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); } } 

Produktion:

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

Få værdier

javatuples-biblioteket giver os også mulighed for at hente værdier fra tuple ved det angivne indeks ved at bruge getValueX() metode. Hvor X angiver objektets indeksværdi. Indeksering starter fra 0.

Eksempel:

 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()); } } 

Produktion:

 [Andrew] 

Indstil værdier

Som vi diskuterede ovenfor er tupler uforanderlige. Derfor kan de ikke ændres, når de først er oprettet. For at overvinde problemet giver javatuples-biblioteket sætVærdiX() metode. Hvor X er den indeksværdi, som vi ønsker at indstille den specifikke værdi til. Metoden opretter en kopi af tuple med den nyligt tilføjede værdi ved det angivne indeks og returnerer den samme tuple.

Eksempel:

int streng

 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); } } 

Produktion:

 [67, 68] 

Tilføjelse af en værdi

Der er to måder at tilføje værdier i en tuple:

• I slutningen af ​​tuplet
• Ved specifikt indeks

I slutningen af ​​Tuple

Javatuples-biblioteket giver tilføje() metode til at tilføje objekter til tuple. Den tilføjer objektet i slutningen af ​​tuplen og returnerer en ny tuple ved at matche antallet af elementer.

Antag, at vi har en tupel med to elementer, og vi ønsker at tilføje et andet element til tupelen. I et sådant tilfælde vil par-tuplen ikke understøtte det tredje element. Derfor, når vi tilføjer et element til en par tupel, bliver det konverteret til en triplet tupel. Lad os se et eksempel.

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); } } 

Produktion:

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

Vi kan også tilføje en tuple til en anden tuple. Det øger antallet af elementer i den nyligt genererede tupel. Derfor returnerer den typen af ​​tupel baseret på antallet af elementer, der er til stede efter tilføjelse.

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); } } 

Produktion:

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

Ved specificeret indeks

Som standard tilføjes nye elementer i slutningen af ​​tuplen. Men vi kan tilføje elementer ved det angivne indeks ved at bruge addX() metode.

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); } } 

Produktion:

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

Søgning efter et element

Vi kan også søge efter et element, der ligger i tuplet. For at søge javatuples bibliotek giver indeholder() Tuple-klassens metode. Det returnerer en boolsk værdi rigtigt hvis et element er til stede, returnerer ellers falsk . Lad os se et eksempel.

SearchingElementExample.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); } } 

Produktion:

 true false 

Konverter Tuple til Collection eller Array

Hver tuple-klasse har metoderne asList() og toArray(), der returnerer henholdsvis List og Array. Lad os se et eksempel.

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)); } } 

Produktion:

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

Bemærk, at tuple kan indeholde heterogene typer, så den resulterende type vil være af Liste eller Objekt[] derfor.

Iteration over Tuple

Alle tuple-klasserne implementerer Iterable interface. Så vi kan iterere en tupel på samme måde som samlinger eller 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); } } } 

Produktion:

 Dell 5600.0 34 Digital Solutions 

Tuple vs. Liste/Array