TechCodeview

EN tuppel er en datastruktur som kan inneholde objekter av forskjellige typer. Disse objektene er ikke knyttet til hverandre, men har betydning når vi vurderer dem samlet. I denne delen diskuterer vi hva er tupel , funksjoner, størrelse, og operasjoner av tuppel. Vi vil også diskutere tuppelimplementering i Java .

Hva er en tuppel?

Generelt, a tuppel er en ordnet samling av gjenstander. I tuple lagres data som et objekt i en separat byte-array. Den har kommadelte verdier omsluttet av et par firkantede parenteser []. Tuples er uforanderlig, i motsetning til Lists datastruktur. En tuppel kan inneholde flere tupler. Det kan også betraktes som et anonymt objekt.

Egenskaper til Tuple

Tuple har følgende funksjoner:

• Det er typesikker, gjentakelig, uforanderlig, og serialiserbar .
• Den implementerer toString(), lik(), og hashkoden()
• Den implementerer også Sammenlignbar (Sammenlignbare redskaper)

Tuppel eksempel

La oss vurdere følgende eksempel.

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

Ovennevnte tuppel er en kvartett tuple fordi den har fire elementer (objekter). Vi observerer at hvert objekt er av en annen type. Men når vi vurderer det samlet, har det en bestemt betydning. Ovennevnte tuppel representerer dataene til en ansatt som navn, kjønn, alder og betegnelse.

La oss se noen 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 tuppel en generisk datastruktur som behandler hvert element som et objekt, og disse objektene lagres i en separat byte-array. Med andre ord kan vi også si at tuppel er en bestilt samling av gjenstander av ulike typer.

Funksjonaliteten til en tuppel kan implementeres ved hjelp av List- og Array-datastrukturen, men disse datastrukturene inneholder ikke forskjellige typer datatyper etter design. Derfor er det klart at heterogen tuple ved å bruke en standard datastruktur (List/ Array) er ikke mulig i Java. Siden vi krevde tuppel datastruktur for å oppfylle kravet om beholdning homogen data struktur.

Noter det tuppeldatastruktur er ikke til stede i Java-programmering , som standard. Men vi kan implementere tuppeldatastrukturen ved å bruke tredjepartsbiblioteket som heter javatuples .

Før vi går til implementeringen, vil vi først laste ned javatuples.jar fil. Og legg til denne filen i banen til prosjektet.

Vi kan også bruke følgende avhengighet i pom.xml fil for å implementere tuples datastruktur i Java.

 org.javatuples javatuples 1.2 

La oss implementere en tuppel og lage et enkelt Java-tuppelprogram.

Javatuples bibliotek

De javatuples biblioteket har tuppelklassene som tilsvarer størrelsen på en tuppel. Tupler kan være forskjellige i størrelse. En tuppel kan inneholde maksimalt 10 elementer. Gjennomføringen av hver tuppel er forskjellig. Klassehierarkiet er som følger.

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

Java Tuple klasse

De Tuppel er en abstrakt grunnklasse for alle tuppelklassene som hører til org.javatuples pakke. Alle metodene i tuppelklassen er offentlige og endelige. Følgende tabell oppsummerer metodene for tuppelklassen. Den implementerer Iterable og Serialiserbare grensesnitt.

Direkte kjente underklasser

I tillegg til de ovennevnte klassene, er det to ekstra klasser levert av javatuples-biblioteket, dvs. Nøkkelverdi og LabelValue . Disse to klassene ligner på Par klasse og gir samme funksjonalitet, men i forskjellig semantikk.

Hver tuppelklasse implementerer følgende tre grensesnitt:

• Iterable
• Sammenlignbar
• Serialiserbar

Implementering av Tuple

Implementeringen av en tuppel i Java er veldig enkel. Vi må lage en forekomst av tuppelklasse som tilsvarer størrelsen.

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

Produksjon:

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

Tuple operasjoner

Følgende operasjoner kan utføres på en tuppel:

• Opprette en Tuple
• Få verdier
• Stille inn verdier
• Legge til elementer
• Iterer over Tuple
• Konverter Tuple til List
• Søker i Tuple

Skaper Tuple

Det er tre måter å lage en tuppel på:

• Ved å bruke with()-metoden
• Ved å bruke Constructor
• Ved å bruke samling

La oss se de tre ovennevnte måtene å lage en tuppel på.

Ved å bruke with()-metoden

Javatuples-biblioteket gir med() metode som lager en tuppel med de angitte verdiene. Metoden tilhører org.javatuples.Pair pakke. Den brukes til å instansiere objekter med verdier.

Syntaks:

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

Eksempel:

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

Ovennevnte Pair-klasseobjekt lager en tuppel med to verdier. La oss lage et Java-program for 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); } } 

Produksjon:

 [9086651, Dell Laptop] 

Ved å bruke Constructor

I dette tilfellet oppretter vi en konstruktør av 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); 

La oss lage et Java-program for å lage en tuppel ved hjelp av konstruktør.

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

Produksjon:

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

Ved å bruke samling

Javatuples-biblioteket lar oss lage en tuppel fra samlingen ved å bruke fromCollection() metode. Det lar oss også lage en tuppel fra en matrise ved å bruke fromArray() metode. Merk at samlingen/matrisen må ha samme type og verdier som tuppelen.

Samlingen/matrisen må ha samme type som Tuple og antall verdier i samlingen/matrisen må samsvare med 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); } } 

Produksjon:

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

Få verdier

Javatuples-biblioteket lar oss også hente verdier fra tuppelen ved den angitte indeksen ved å bruke getValueX() metode. Hvor X angir indeksverdien til objektet. 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()); } } 

Produksjon:

 [Andrew] 

Sett verdier

Som vi diskuterte ovenfor er tupler uforanderlige. Derfor kan de ikke endres når de først er opprettet. For å overvinne problemet tilbyr javatuples-biblioteket setValueX() metode. Hvor X er indeksverdien som vi ønsker å sette den spesifikke verdien til. Metoden lager en kopi av tuppelen med den nylig tilførte verdien ved den angitte indeksen og returnerer den samme tuppelen.

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

Produksjon:

 [67, 68] 

Legge til en verdi

Det er to måter å legge til verdier i en tuppel:

• På slutten av tuppelen
• Ved spesifikk indeks

På slutten av Tuple

Javatuples-biblioteket gir Legg til() metode for å legge til objekter i tuppelen. Den legger til objektet på slutten av tuppelen og returnerer en ny tuppel ved å matche antall elementer.

Anta at vi har en tuppel som har to elementer og vi ønsker å legge til et annet element til tuppelen. I et slikt tilfelle vil ikke par-tuppelen støtte det tredje elementet. Derfor, når vi legger til et element til en par-tuppel, blir det konvertert til en trippel-tuppel. La oss 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); } } 

Produksjon:

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

Vi kan også legge til en tuppel til en annen tuppel. Det øker antall elementer i den nylig genererte tuppelen. Derfor returnerer den typen tuppel basert på antall elementer som er tilstede etter addisjon.

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

Produksjon:

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

Ved spesifisert indeks

Som standard legges nye elementer til på slutten av tupelen. Men vi kan legge til elementer ved den angitte indeksen ved å bruke 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); } } 

Produksjon:

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

Søke etter et element

Vi kan også søke etter et element som ligger i tupelen. For å søke i javatuples gir biblioteket inneholder() metoden til Tuple-klassen. Den returnerer en boolsk verdi ekte hvis et element er tilstede, returnerer annet falsk . La oss 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); } } 

Produksjon:

 true false 

Konverter Tuple til Collection eller Array

Hver tuppelklasse har metodene asList() og toArray() som returnerer henholdsvis List og Array. La oss 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)); } } 

Produksjon:

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

Merk at tuppel kan inneholde heterogene typer, så den resulterende typen vil være av Liste eller Gjenstand[] tilsvarende.

Iterasjon over Tuple

Alle tuppelklassene implementerer Iterable grensesnitt. Så vi kan iterere en tuppel på samme måte som samlinger eller matriser.

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

Produksjon:

 Dell 5600.0 34 Digital Solutions 

Tuple vs. Liste/Array