UN tuple est une structure de données pouvant contenir des objets de différents types. Ces objets ne sont pas liés les uns aux autres mais ont un sens lorsqu’on les considère collectivement. Dans cette section, nous discutons qu'est-ce que le tuple , caractéristiques, taille, et opérations de tuples. Nous discuterons également de implémentation de tuples en Java .

Qu'est-ce qu'un tuple ?

En général, un tuple est une collection ordonnée d’objets. Dans un tuple, les données sont stockées en tant qu'objet dans un tableau d'octets distinct. Il comporte des valeurs séparées par des virgules et entourées de crochets []. Les tuples sont immuable, contrairement à la structure de données des listes. Un tuple peut contenir plusieurs tuples. Il peut également être considéré comme un objet anonyme.

Caractéristiques du tuple

Tuple a les fonctionnalités suivantes :

• C'est typesafe, itérable, immuable, et sérialisable .
• Il met en œuvre le toString(), est égal à(), et le hashCode()
• Il met également en œuvre le Comparable (Tuple implémente Comparable)

Exemple de tuple

Considérons l'exemple suivant.

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

Le tuple ci-dessus est un quatuor tuple parce qu'il a quatre éléments (objets). On observe que chaque objet est d'un type différent. Mais lorsque nous l’envisageons collectivement, il revêt une signification particulière. Le tuple ci-dessus représente les données d'un employé telles que son nom, son sexe, son âge et sa désignation.

Voyons quelques autres exemples de tuples.

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

Tuple en Java

En Java, un tuple est une structure de données générique qui traite chaque élément comme un objet, et ces objets sont stockés dans un tableau d'octets distinct. En d’autres termes, on peut aussi dire que tuple est un commandé collection d'objets de différents types.

arbre de recherche binaire

La fonctionnalité d'un tuple peut être implémentée à l'aide des structures de données List et Array, mais ces structures de données ne contiennent pas différents types de types de données par conception. Il est donc clair que hétérogène un tuple utilisant une structure de données standard (Liste/Array) n'est pas possible en Java. Puisque nous avions besoin tuple structure de données pour répondre à l’exigence de détention homogène Structure de données.

Noter que la structure de données tuple n'est pas présente dans la programmation Java , par défaut. Mais nous pouvons implémenter la structure de données tuple en utilisant la bibliothèque tierce nommée javatuples .

Avant de passer à l'implémentation, nous allons d'abord télécharger le javatuples.jar déposer. Et ajoutez ce fichier au chemin du projet.

Nous pouvons également utiliser la dépendance suivante dans pom.xml fichier pour implémenter la structure de données des tuples en Java.

 org.javatuples javatuples 1.2 

Implémentons un tuple et créons un simple programme de tuple Java.

Bibliothèque Javatuples

Le javatuples La bibliothèque contient les classes de tuples qui correspondent à la taille d'un tuple. Les tuples peuvent être de taille différente. Un tuple peut contenir un maximum de dix éléments. L'implémentation de chaque tuple est différente. La hiérarchie des classes est la suivante.

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

Classe de tuple Java

Le Tuple est une classe de base abstraite pour toutes les classes de tuples appartenant à org.javatuples emballer. Toutes les méthodes de la classe tuple sont publiques et définitives. Le tableau suivant résume les méthodes de la classe tuple. Il implémente des interfaces itérables et sérialisables.

Sous-classes connues directes

Outre les classes ci-dessus, il existe deux classes supplémentaires fournies par la bibliothèque javatuples, à savoir Valeur clé et ValeurÉtiquette . Ces deux classes sont similaires aux Paire classe et fournissent les mêmes fonctionnalités mais dans une sémantique différente.

Chaque classe de tuple implémente les trois interfaces suivantes :

• Itérable
• Comparable
• Sérialisable

Implémentation de Tuple

L’implémentation d’un tuple en Java est très simple. Nous devons créer une instance de classe tuple qui correspond à la taille.

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

Sortir:

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

Opérations sur les tuples

Les opérations suivantes peuvent être effectuées sur un tuple :

• Créer un tuple
• Obtenir des valeurs
• Définition des valeurs
• Ajout d'éléments
• Itérer sur Tuple
• Convertir un tuple en liste
• Recherche dans un tuple

Création d'un tuple

Il existe trois manières de créer un tuple :

• En utilisant la méthode with()
• En utilisant le constructeur
• En utilisant la collection

Voyons les trois façons ci-dessus de créer un tuple.

En utilisant la méthode with()

La bibliothèque javatuples fournit le avec() méthode qui crée un tuple avec les valeurs spécifiées. La méthode appartient au org.javatuples.Paire emballer. Il est utilisé pour instancier des objets avec des valeurs.

javascript pour la liste déroulante

Syntaxe:

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

Exemple:

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

L'objet de classe Pair ci-dessus crée un tuple avec deux valeurs. Créons un programme Java pour la même chose.

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

Sortir:

 [9086651, Dell Laptop] 

En utilisant le constructeur

Dans ce cas, nous créons un constructeur de classe, selon les besoins.

Syntaxe:

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

Exemple:

annotations dans Spring Boot

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

Créons un programme Java pour créer un tuple à l'aide d'un constructeur.

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

Sortir:

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

En utilisant la collection

La bibliothèque javatuples nous permet de créer un tuple à partir de la collection en utilisant le deCollection() méthode. Cela nous permet également de créer un tuple à partir d'un tableau en utilisant le fromArray() méthode. Notez que la collection/le tableau doit avoir le même type et les mêmes valeurs que le tuple.

La collection/tableau doit avoir le même type que le Tuple et le nombre de valeurs dans la collection/le tableau doit correspondre à la classe Tuple.

Syntaxe:

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

Sortir:

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

Obtenir des valeurs

La bibliothèque javatuples nous permet également de récupérer les valeurs du tuple à l'index spécifié en utilisant le obtenirValueX() méthode. Où X désigne la valeur d'index de l'objet. L'indexation commence à 0.

java pour la pause

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

Sortir:

 [Andrew] 

Définir des valeurs

Comme nous l'avons vu ci-dessus, les tuples sont immuables. Ils ne peuvent donc pas être modifiés une fois créés. Pour résoudre le problème, la bibliothèque javatuples fournit le setValueX() méthode. Où X est la valeur d'index à laquelle nous voulons définir la valeur spécifique. La méthode crée une copie du tuple avec la valeur nouvellement ajoutée à l'index spécifié et renvoie le même tuple.

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

Sortir:

 [67, 68] 

Ajouter une valeur

Il existe deux manières d'ajouter des valeurs dans un tuple :

• A la fin du tuple
• À un index spécifique

A la fin du tuple

La bibliothèque javatuples fournit le ajouter() méthode pour ajouter des objets au tuple. Il ajoute l'objet à la fin du tuple et renvoie un nouveau tuple en faisant correspondre le nombre d'éléments.

Supposons que nous ayons un tuple comportant deux éléments et que nous souhaitions ajouter un autre élément au tuple. Dans un tel cas, le tuple Pair ne prendra pas en charge le troisième élément. Par conséquent, lorsque nous ajoutons un élément à un tuple Pair, il est converti en tuple Triplet. Voyons 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); } } 

Sortir:

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

Nous pouvons également ajouter un tuple à un autre tuple. Cela augmente le nombre d'éléments dans le tuple nouvellement généré. Par conséquent, il renvoie le type de tuple en fonction du nombre d'éléments présents après l'ajout.

déclaration d'impression en Java

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

Sortir:

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

À l'indice spécifié

Par défaut, les nouveaux éléments sont ajoutés à la fin du tuple. Mais nous pouvons ajouter des éléments à l'index spécifié en utilisant le ajouterX() méthode.

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

Sortir:

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

Rechercher un élément

Nous pouvons également rechercher un élément qui réside dans le tuple. Pour la recherche, la bibliothèque javatuples fournit le contient() méthode de la classe Tuple. Il renvoie une valeur booléenne vrai si un élément est présent, else renvoie FAUX . Voyons 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); } } 

Sortir:

 true false 

Convertir un tuple en collection ou en tableau

Chaque classe de tuple possède les méthodes asList() et toArray() qui renvoient respectivement List et Array. Voyons 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)); } } 

Sortir:

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

Notez que le tuple peut contenir des types hétérogènes donc le type résultant sera de Liste ou Objet[] par conséquent.

Itération sur tuple

Toutes les classes de tuples implémentent le Itérable interface. Ainsi, nous pouvons parcourir un tuple de la même manière que des collections ou des tableaux.

ItérerTuple.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); } } } 

Sortir:

 Dell 5600.0 34 Digital Solutions 

Tuple contre. Liste/Tableau