TechCodeview

A tuppel är en datastruktur som kan hålla objekt av olika typer. Dessa föremål är inte kopplade till varandra utan har betydelse när vi betraktar dem kollektivt. I det här avsnittet diskuterar vi vad är tupel , funktioner, storlek, och operationer av tuplar. Vi kommer också att diskutera tupelimplementering i Java .

Vad är en tuppel?

I allmänhet, a tuppel är en ordnad samling av föremål. I tuppel lagras data som ett objekt i en separat byte-array. Den har kommaseparerade värden inom ett par hakparenteser []. Tuples är oföränderlig, till skillnad från Lists datastruktur. En tupel kan hålla flera tuplar. Det kan också betraktas som ett anonymt objekt.

Funktioner hos Tuple

Tuple har följande funktioner:

• Det är typsäker, iterabel, oföränderlig, och serialiserbar .
• Den implementerar toString(), lika med(), och hashkoden()
• Den implementerar också Jämförbar (Jämförbara redskap med tuppel)

Tuple Exempel

Låt oss överväga följande exempel.

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

Ovanstående tupel är en kvartett tuple eftersom det har fyra element (objekt). Vi observerar att varje objekt är av olika typ. Men när vi betraktar det kollektivt har det en specifik betydelse. Ovanstående tuppel representerar uppgifterna för en anställd såsom namn, kön, ålder och beteckning.

Låt oss se några andra exempel på tupler.

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

Tuple i Java

I Java är en tupel en generisk datastruktur som behandlar varje element som ett objekt, och dessa objekt lagras i en separat byte-array. Med andra ord kan vi också säga att tupel är en beordrade samling av föremål av olika slag.

Funktionaliteten hos en tupel kan implementeras med hjälp av List- och Array-datastrukturen, men dessa datastrukturer innehåller inte olika typer av datatyper genom design. Därför är det klart att heterogen tuple med en standarddatastruktur (List/Array) är inte möjligt i Java. Eftersom vi krävde tuppel datastruktur för att uppfylla kravet på innehav homogen datastruktur.

Anteckna det tupeldatastruktur finns inte i Java-programmering , som standard. Men vi kan implementera tupeldatastrukturen genom att använda det namngivna tredjepartsbiblioteket javatuples .

Innan vi går till implementeringen kommer vi först att ladda ner javatuples.jar fil. Och lägg till den här filen i projektets sökväg.

Vi kan också använda följande beroende i pom.xml fil för att implementera tuples datastruktur i Java.

 org.javatuples javatuples 1.2 

Låt oss implementera en tuppel och skapa ett enkelt Java tuppelprogram.

tostring java

Javatuples bibliotek

De javatuples biblioteket har de tuppelklasser som motsvarar storleken på en tupel. Tuplar kan vara olika i storlek. En tuppel får innehålla max 10 element. Implementeringen av varje tupel är olika. Klasshierarkin är som följer.

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

Java Tuple klass

De Tuple är en abstrakt basklass för alla tupelklasser som hör till org.javatuples paket. Alla metoder i tuppelklassen är offentliga och slutgiltiga. Följande tabell sammanfattar metoderna för tupelklassen. Den implementerar Iterable och Serialiserbara gränssnitt.

Direkt kända underklasser

Förutom ovanstående klasser finns det ytterligare två klasser som tillhandahålls av javatuples bibliotek, dvs. Nyckelvärde och LabelValue . Dessa två klasser liknar Par klass och ger samma funktionalitet men i olika semantik.

Varje tupelklass implementerar följande tre gränssnitt:

• Iterable
• Jämförbar
• Serialiserbar

Implementering av Tuple

Implementeringen av en tupel i Java är mycket enkel. Vi måste skapa en instans av tupelklass som motsvarar storleken.

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 Operations

Följande operationer kan utföras på en tupel:

• Skapa en Tuple
• Få värden
• Ställa in värden
• Lägga till element
• Iterera över Tuple
• Konvertera Tuple till List
• Söker i Tuple

Skapar Tuple

Det finns tre sätt att skapa en tupel:

• Genom att använda metoden with().
• Genom att använda Constructor
• Genom att använda Collection

Låt oss se ovanstående tre sätt att skapa en tupel.

Genom att använda metoden with().

Javatuples-biblioteket tillhandahåller med() metod som skapar en tupel med de angivna värdena. Metoden tillhör org.javatuples.Pair paket. Den används för att instansiera objekt med värden.

Syntax:

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

Exempel:

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

Ovanstående parklassobjekt skapar en tupel med två värden. Låt oss skapa ett Java-program för detsamma.

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] 

Genom att använda Constructor

I det här fallet skapar vi en konstruktör av klassen, enligt krav.

: i java

Syntax:

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

Exempel:

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

Låt oss skapa ett Java-program för att skapa en tupel med konstruktor.

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] 

Genom att använda Collection

Javatuples-biblioteket låter oss skapa en tupel från samlingen genom att använda fromCollection() metod. Det låter oss också skapa en tupel från en array genom att använda fromArray() metod. Observera att samlingen/arrayen måste ha samma typ och värden som tupeln.

Samlingen/matrisen måste ha samma typ som Tuple och antalet värden i samlingen/arrayen måste matcha Tuple-klassen.

Syntax:

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

Exempel:

 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ärden

Javatuples-biblioteket låter oss också hämta värden från tupeln vid det angivna indexet genom att använda getValueX() metod. Där X anger objektets indexvärde. Indexering börjar från 0.

Exempel:

 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] 

Ställ in värden

Som vi diskuterade ovan är tupler oföränderliga. Därför kan de inte ändras när de väl har skapats. För att lösa problemet tillhandahåller javatuples bibliotek setValueX() metod. Där X är det indexvärde som vi vill ställa in det specifika värdet på. Metoden skapar en kopia av tupeln med det nytillförda värdet vid det angivna indexet och returnerar samma tupel.

Exempel:

 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] 

Lägga till ett värde

Det finns två sätt att lägga till värden i en tupel:

• I slutet av tupeln
• Vid specifikt index

I slutet av Tuplen

Javatuples-biblioteket tillhandahåller Lägg till() metod för att lägga till objekt till tupeln. Den lägger till objektet i slutet av tupeln och returnerar en ny tupel genom att matcha antalet element.

Anta att vi har en tuppel som har två element och vi vill lägga till ytterligare ett element till tupeln. I ett sådant fall kommer inte par-tuppeln att stödja det tredje elementet. Därför, när vi lägger till ett element till en par-tuppel, omvandlas det till en trippel-tuppel. Låt oss se ett exempel.

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 också lägga till en tuppel till en annan tuppel. Det ökar antalet element i den nygenererade tupeln. Därför returnerar den typen av tuppel baserat på antalet element som finns efter tillägg.

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] 

Vid specificerat index

Som standard läggs nya element till i slutet av tupeln. Men vi kan lägga till element vid det angivna indexet genom att använda addX() metod.

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öka efter ett element

Vi kan också söka efter ett element som finns i tupeln. För att söka javatuples biblioteket tillhandahåller innehåller() metod för Tuple-klassen. Det returnerar ett booleskt värde Sann om ett element är närvarande, returnerar else falsk . Låt oss se ett exempel.

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 

Konvertera Tuple till Collection eller Array

Varje tupelklass har metoderna asList() och toArray() som returnerar List respektive Array. Låt oss se ett exempel.

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] 

Observera att tupel kan innehålla heterogena typer så den resulterande typen kommer att vara av Lista eller Objekt[] följaktligen.

uppdaterar java

Iteration över Tuple

Alla tupelklasser implementerar Iterable gränssnitt. Så vi kan iterera en tupel på samma sätt som samlingar eller arrayer.

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. Lista/Array