UN tupla è una struttura dati che può contenere oggetti di diverso tipo. Questi oggetti non sono collegati tra loro ma hanno un significato se li consideriamo collettivamente. In questa sezione discutiamo cos'è la tupla , caratteristiche, dimensioni, E operazioni di tuple. Inoltre, discuteremo di implementazione della tupla in Java .

Cos'è una tupla?

In generale, a tupla è una raccolta ordinata di oggetti. Nella tupla i dati vengono archiviati come oggetto in un array di byte separato. Ha valori separati da virgole racchiusi tra parentesi quadre []. Le tuple lo sono immutabile, a differenza della struttura dei dati di Lists. Una tupla può contenere più tuple. Può anche essere considerato un oggetto anonimo.

Caratteristiche di Tupla

Tuple ha le seguenti funzionalità:

• È typesafe, iterabile, immutabile, E serializzabile .
• Implementa il toString(), uguale(), E il codice hash()
• Implementa anche il Paragonabile (Tuple implementa Comparable)

Esempio di tupla

Consideriamo il seguente esempio.

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

La tupla sopra è a quartetto tuple perché lo ha quattro elementi (oggetti). Osserviamo che ogni oggetto è di tipo diverso. Ma quando lo consideriamo collettivamente, ha un significato specifico. La tupla sopra rappresenta i dati di un dipendente come nome, sesso, età e designazione.

Vediamo qualche altro esempio di tuple.

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

Tupla in Java

In Java, una tupla è una struttura dati generica che tratta ogni elemento come un oggetto e questi oggetti vengono archiviati in un array di byte separato. In altre parole, possiamo anche dire che la tupla è un ordinato raccolta di oggetti di diverso tipo.

La funzionalità di una tupla può essere implementata utilizzando la struttura dati List e Array, ma queste strutture dati non contengono diversi tipi di dati in base alla progettazione. Quindi, è chiaro che eterogeneo tuple che utilizza una struttura dati standard (Lista/Array) non è possibile in Java. Dal momento che abbiamo richiesto tupla struttura dei dati per soddisfare il requisito di conservazione omogeneo struttura dati.

Notare che la struttura dati della tupla non è presente nella programmazione Java , per impostazione predefinita. Ma possiamo implementare la struttura dei dati della tupla utilizzando la libreria di terze parti denominata javatuples .

Prima di passare all'implementazione, scaricheremo innanzitutto il file javatuples.jar file. E aggiungi questo file al percorso del progetto.

Possiamo anche usare la seguente dipendenza in pom.xml file per implementare la struttura dati delle tuple in Java.

 org.javatuples javatuples 1.2 

Implementiamo una tupla e creiamo un semplice programma tupla Java.

Libreria Javatuples

IL javatuples La libreria ha le classi tupla che corrispondono alla dimensione di una tupla. Le tuple possono avere dimensioni diverse. Una tupla può contenere un massimo di 10 elementi. L'implementazione di ciascuna tupla è diversa. La gerarchia delle classi è la seguente.

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

Classe tupla Java

IL Tupla è una classe base astratta per tutte le classi tuple a cui appartiene org.javatuples pacchetto. Tutti i metodi della classe tupla sono pubblici e finali. La tabella seguente riassume i metodi della classe tupla. Implementa interfacce Iterable e Serializable.

Sottoclassi conosciute dirette

Oltre alle classi di cui sopra, ci sono due classi aggiuntive fornite dalla libreria javatuples, ad es. Valorechiave E EtichettaValore . Queste due classi sono simili a Paio classe e forniscono la stessa funzionalità ma con semantica diversa.

Ogni classe tupla implementa le seguenti tre interfacce:

• Iterabile
• Paragonabile
• Serializzabile

Implementazione di Tupla

L'implementazione di una tupla in Java è molto semplice. Dobbiamo creare un'istanza della classe tupla che corrisponda alla dimensione.

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

Produzione:

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

Operazioni sulle tuple

Su una tupla è possibile eseguire le seguenti operazioni:

• Creazione di una tupla
• Ottenere valori
• Impostazione dei valori
• Aggiunta di elementi
• Itera su Tupla
• Converti tupla in lista
• Ricerca in tupla

Creazione della tupla

Esistono tre modi per creare una tupla:

• Utilizzando il metodo with()
• Utilizzando il costruttore
• Utilizzando la raccolta

Vediamo i tre modi precedenti per creare una tupla.

Utilizzando il metodo with()

La libreria javatuples fornisce il file con() metodo che crea una tupla con i valori specificati. Il metodo appartiene a org.javatuples.Pair pacchetto. Viene utilizzato per istanziare oggetti con valori.

Sintassi:

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

Esempio:

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

L'oggetto classe Pair sopra crea una tupla con due valori. Creiamo un programma Java per lo stesso.

CreateTupleEsempio1.java

cos'è uno stack Java

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

Produzione:

 [9086651, Dell Laptop] 

Utilizzando il costruttore

In questo caso creiamo un costruttore della classe, in base ai requisiti.

Sintassi:

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

Esempio:

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

Creiamo un programma Java per creare una tupla utilizzando il costruttore.

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

Produzione:

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

Utilizzando la raccolta

La libreria javatuples ci consente di creare una tupla dalla raccolta utilizzando il file dalla raccolta() metodo. Ci consente anche di creare una tupla da un array utilizzando il metodo daArray() metodo. Tieni presente che la raccolta/array deve avere lo stesso tipo e valori della tupla.

La raccolta/array deve avere lo stesso tipo della Tupla e il numero di valori nella raccolta/array deve corrispondere alla classe Tuple.

Sintassi:

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

Esempio:

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

Produzione:

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

Ottieni valori

La libreria javatuples ci consente anche di recuperare valori dalla tupla all'indice specificato utilizzando il file getValoreX() metodo. Dove X indica il valore dell'indice dell'oggetto. L'indicizzazione inizia da 0.

Esempio:

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

Produzione:

 [Andrew] 

Impostare i valori

Come abbiamo discusso sopra, le tuple sono immutabili. Pertanto, non possono essere modificati una volta creati. Per superare il problema, la libreria javatuples fornisce il file setValoreX() metodo. Dove X è il valore dell'indice al quale vogliamo impostare il valore specifico. Il metodo crea una copia della tupla con il valore appena aggiunto all'indice specificato e restituisce la stessa tupla.

Esempio:

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

Produzione:

 [67, 68] 

Aggiunta di un valore

Esistono due modi per aggiungere valori in una tupla:

• Alla fine della tupla
• All'indice specifico

Alla fine della Tupla

La libreria javatuples fornisce il file aggiungere() metodo per aggiungere oggetti alla tupla. Aggiunge l'oggetto alla fine della tupla e restituisce una nuova tupla facendo corrispondere il numero di elementi.

Supponiamo di avere una tupla con due elementi e di voler aggiungere un altro elemento alla tupla. In tal caso, la tupla Pair non supporterà il terzo elemento. Pertanto, quando aggiungiamo un elemento a una tupla Coppia, viene convertito in una tupla Tripletta. Vediamo un esempio.

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

Produzione:

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

Possiamo anche aggiungere una tupla a un'altra tupla. Aumenta il numero di elementi nella tupla appena generata. Quindi restituisce il tipo di tupla in base al numero di elementi presenti dopo l'addizione.

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

Produzione:

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

All'indice specificato

Per impostazione predefinita, i nuovi elementi vengono aggiunti alla fine della tupla. Ma possiamo aggiungere elementi all'indice specificato utilizzando il metodo aggiungiX() metodo.

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

Produzione:

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

Ricerca di un elemento

Possiamo anche cercare un elemento che risiede nella tupla. Per la ricerca la libreria Javatuples fornisce il file contiene() metodo della classe Tuple. Restituisce un valore booleano VERO se un elemento è presente, altrimenti restituisce falso . Vediamo un esempio.

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

Produzione:

 true false 

Converti tupla in raccolta o array

Ogni classe tupla ha metodi asList() e toArray() che restituiscono rispettivamente List e Array. Vediamo un esempio.

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

Produzione:

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

Tieni presente che la tupla può contenere tipi eterogenei, quindi il tipo risultante sarà di Elenco O Oggetto[] di conseguenza.

Iterazione su tupla

Tutte le classi tupla implementano il file Iterabile interfaccia. Quindi, possiamo iterare una tupla allo stesso modo delle raccolte o degli array.

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

Produzione:

 Dell 5600.0 34 Digital Solutions 

Tupla vs. Elenco/Array