TechCodeview

A tupla és una estructura de dades que pot contenir objectes de diferents tipus. Aquests objectes no estan connectats entre si, sinó que tenen significat quan els considerem col·lectivament. En aquesta secció, parlem què és la tupla , característiques, mida, i operacions de tuples. A més, parlarem del implementació de tuples en Java .

Què és una tupla?

En general, a tupla és una col·lecció ordenada d'objectes. En tuple, les dades s'emmagatzemen com a objecte en una matriu de bytes separada. Té valors separats per comes tancats entre claudàtors []. Les tuples ho són immutable, a diferència de l'estructura de dades de Llistes. Una tupla pot contenir múltiples tuples. També es pot considerar com un objecte anònim.

Característiques de Tuple

Tuple té les següents característiques:

• És tipus segur, iterable, immutable, i serializable .
• Implementa el toString(), és igual a(), i el codi hash()
• També implementa el Comparable (Implements de tuple comparables)

Exemple de tuple

Considerem l'exemple següent.

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

La tupla anterior és a quartet tupla perquè té quatre elements (objectes). Observem que cada objecte és d'un tipus diferent. Però quan ho considerem col·lectivament, té un significat específic. La tupla anterior representa les dades d'un empleat, com ara el nom, el sexe, l'edat i la designació.

tutorial de seleni

Vegem alguns altres exemples de tuples.

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

Tupla a Java

A Java, una tupla és una estructura de dades genèrica que tracta cada element com un objecte, i aquests objectes s'emmagatzemen en una matriu de bytes independent. En altres paraules, també podem dir que la tupla és an ordenat col·lecció d'objectes de diferents tipus.

La funcionalitat d'una tupla es pot implementar mitjançant l'estructura de dades List i Array, però aquestes estructures de dades no contenen diferents tipus de tipus de dades per disseny. Per tant, queda clar que heterogeni La tupla utilitzant una estructura de dades estàndard (List/ Array) no és possible a Java. Ja que ho exigim tupla estructura de dades per complir amb el requisit de tenir homogeni estructura de dades.

Tingues en compte que L'estructura de dades de tupla no està present a la programació Java , per defecte. Però podem implementar l'estructura de dades de tuple utilitzant la biblioteca de tercers anomenada javatuples .

Abans de passar a la implementació, primer, descarregarem el javatuples.jar dossier. I afegiu aquest fitxer a la ruta del projecte.

També podem utilitzar la següent dependència a pom.xml fitxer per implementar l'estructura de dades de tuples a Java.

 org.javatuples javatuples 1.2 

Implementem una tupla i creem un simple programa de tupla Java.

Biblioteca Javatuples

El javatuples La biblioteca té les classes de tupla que corresponen a la mida d'una tupla. Les tuples poden tenir una mida diferent. Una tupla pot contenir un màxim de 10 elements. La implementació de cada tupla és diferent. La jerarquia de classes és la següent.

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

Classe de tuple Java

El Tuple és una classe base abstracta per a totes les classes de tuples a les quals pertany org.javatuples paquet. Tots els mètodes de la classe tuple són públics i finals. La taula següent resumeix els mètodes de la classe de tuples. Implementa interfícies iterables i serialitzables.

Subclasses conegudes directes

A més de les classes anteriors, hi ha dues classes addicionals proporcionades per la biblioteca javatuples, és a dir. KeyValue i LabelValue . Aquestes dues classes són similars a les Parella classe i proporcionen la mateixa funcionalitat però amb una semàntica diferent.

Cada classe de tuple implementa les tres interfícies següents:

• Iterable
• Comparable
• Serialitzable

Implementació de Tuple

La implementació d'una tupla a Java és molt fàcil. Hem de crear una instància de classe de tupla que correspongui a la mida.

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

Sortida:

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

Operacions de tuples

Les operacions següents es poden realitzar en una tupla:

• Creació d'una tupla
• Obtenció de valors
• Establiment de valors
• Afegir Elements
• Iterar sobre Tuple
• Converteix tupla a llista
• Buscant en tuple

Creació de tuple

Hi ha tres maneres de crear una tupla:

• Mitjançant l'ús del mètode with().
• Mitjançant l'ús del constructor
• Mitjançant l'ús de la col·lecció

Vegem les tres maneres anteriors de crear una tupla.

Mitjançant l'ús del mètode with().

La biblioteca javatuples proporciona el amb () mètode que crea una tupla amb els valors especificats. El mètode pertany al org.javatuples.Pair paquet. S'utilitza per crear una instancia d'objectes amb valors.

Sintaxi:

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

Exemple:

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

L'objecte de classe Pair anterior crea una tupla amb dos valors. Creem un programa Java per al mateix.

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

Sortida:

 [9086651, Dell Laptop] 

Mitjançant l'ús del constructor

En aquest cas, creem un constructor de la classe, segons el requisit.

Sintaxi:

comentari javascript

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

Exemple:

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

Creem un programa Java per crear una tupla utilitzant el 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); } } 

Sortida:

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

Mitjançant l'ús de la col·lecció

La biblioteca javatuples ens permet crear una tupla a partir de la col·lecció mitjançant l' de la col·lecció() mètode. També ens permet crear una tupla a partir d'una matriu mitjançant l' fromArray() mètode. Tingueu en compte que la col·lecció/matriu ha de tenir el mateix tipus i valors que la tupla.

La col·lecció/matriu ha de tenir el mateix tipus que la tupla i el nombre de valors de la col·lecció/matriu ha de coincidir amb la classe de tupla.

Sintaxi:

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

Exemple:

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

Sortida:

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

Obtenir valors

La biblioteca javatuples també ens permet obtenir valors de la tupla a l'índex especificat mitjançant el getValueX() mètode. On X indica el valor de l'índex de l'objecte. La indexació comença des de 0.

Exemple:

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

Sortida:

 [Andrew] 

Establir valors

Com hem comentat anteriorment, les tuples són immutables. Per tant, no es poden modificar un cop creats. Per solucionar el problema, la biblioteca javatuples proporciona el setValueX() mètode. On X és el valor de l'índex al qual volem establir el valor específic. El mètode crea una còpia de la tupla amb el valor afegit recentment a l'índex especificat i retorna la mateixa tupla.

Exemple:

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

Sortida:

 [67, 68] 

Afegir un valor

Hi ha dues maneres d'afegir valors en una tupla:

powershell major o igual

• Al final de la tupla
• A un índex específic

Al final de la Tuple

La biblioteca javatuples proporciona el afegir() mètode per afegir objectes a la tupla. Afegeix l'objecte al final de la tupla i torna una nova tupla fent coincidir el nombre d'elements.

Suposem que tenim una tupla que té dos elements i volem afegir un altre element a la tupla. En aquest cas, la tupla Parella no admetrà el tercer element. Per tant, quan afegim un element a una tupla Parella, es converteix en una tupla Triplet. Vegem un exemple.

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

Sortida:

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

També podem afegir una tupla a una altra tupla. Augmenta el nombre d'elements a la tupla recentment generada. Per tant, retorna el tipus de tupla en funció del nombre d'elements presents després de l'addició.

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

Sortida:

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

A l'índex especificat

Per defecte, s'afegeixen nous elements al final de la tupla. Però podem afegir elements a l'índex especificat mitjançant l' addX() mètode.

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

Sortida:

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

Buscant un element

També podem cercar un element que resideix a la tupla. Per a la cerca de Javatuples, la biblioteca ofereix el conté () mètode de la classe Tuple. Retorna un valor booleà veritat si hi ha un element, en cas contrari retorna fals . Vegem un exemple.

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

Sortida:

 true false 

Converteix tupla a col·lecció o matriu

Cada classe de tupla té els mètodes asList() i toArray() que retornen List i Array, respectivament. Vegem un exemple.

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

Sortida:

edat de mia khalifa

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

Tingueu en compte que la tupla pot contenir tipus heterogenis, de manera que el tipus resultant serà de Llista o Objecte[] d'acord amb.

Iteració sobre tuple

Totes les classes de tuples implementen el Iterable interfície. Per tant, podem iterar una tupla de la mateixa manera que les col·leccions o les matrius.

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

Sortida:

 Dell 5600.0 34 Digital Solutions 

Tuple vs. Llista/Matriu