A Tupel ist eine Datenstruktur, die Objekte unterschiedlichen Typs enthalten kann. Diese Objekte sind nicht miteinander verbunden, haben aber eine Bedeutung, wenn wir sie gemeinsam betrachten. In diesem Abschnitt diskutieren wir Was ist Tupel? , Merkmale, Größe, Und Operationen von Tupeln. Außerdem werden wir das besprechen Tupelimplementierung in Java .

Was ist ein Tupel?

Im Allgemeinen a Tupel ist eine geordnete Sammlung von Objekten. In Tupeln werden Daten als Objekt in einem separaten Byte-Array gespeichert. Es enthält durch Kommas getrennte Werte, die in zwei eckige Klammern [] eingeschlossen sind. Tupel sind unveränderlich, im Gegensatz zur Datenstruktur von Listen. Ein Tupel kann mehrere Tupel enthalten. Es kann auch als anonymes Objekt betrachtet werden.

Merkmale von Tuple

Tuple hat die folgenden Funktionen:

• Es ist typsicher, iterierbar, unveränderlich, Und serialisierbar .
• Es implementiert die toString(), equal(), Und der hashCode()
• Es implementiert auch die Vergleichbar (Tuple implementiert Comparable)

Tupel-Beispiel

Betrachten wir das folgende Beispiel.

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

Das obige Tupel ist ein Quartett Tupel, weil es so ist vier Elemente (Objekte). Wir beobachten, dass jedes Objekt von einem anderen Typ ist. Aber wenn wir es gemeinsam betrachten, hat es eine spezifische Bedeutung. Das obige Tupel repräsentiert die Daten eines Mitarbeiters wie Name, Geschlecht, Alter und Bezeichnung.

Sehen wir uns einige andere Beispiele für Tupel an.

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

Tupel in Java

In Java ist ein Tupel eine generische Datenstruktur, die jedes Element als Objekt behandelt und diese Objekte in einem separaten Byte-Array speichert. Mit anderen Worten, wir können auch sagen, dass Tupel ein ist bestellt Sammlung von Objekten unterschiedlicher Art.

Die Funktionalität eines Tupels kann mithilfe der Listen- und Array-Datenstrukturen implementiert werden, diese Datenstrukturen enthalten jedoch nicht konstruktionsbedingt unterschiedliche Datentypen. Daher ist es klar, dass heterogen Tuple mit einer Standarddatenstruktur (Liste/Array) ist in Java nicht möglich. Da wir es brauchten Tupel Datenstruktur, um die Anforderung des Haltens zu erfüllen homogen Datenstruktur.

Beachten Sie, dass Die Tupeldatenstruktur ist in der Java-Programmierung nicht vorhanden , standardmäßig. Aber wir können die Tupel-Datenstruktur implementieren, indem wir die genannte Drittanbieterbibliothek verwenden javatuples .

Sammlungen in Java

Bevor wir mit der Implementierung fortfahren, laden wir zunächst die herunter javatuples.jar Datei. Und fügen Sie diese Datei zum Pfad des Projekts hinzu.

Wir können auch die folgende Abhängigkeit verwenden pom.xml Datei zum Implementieren der Tupel-Datenstruktur in Java.

 org.javatuples javatuples 1.2 

Lassen Sie uns ein Tupel implementieren und ein einfaches Java-Tupelprogramm erstellen.

Javatuples-Bibliothek

Der javatuples Die Bibliothek verfügt über die Tupelklassen, die der Größe eines Tupels entsprechen. Tupel können unterschiedlich groß sein. Ein Tupel kann maximal enthalten 10 Elemente. Die Implementierung jedes Tupels ist unterschiedlich. Die Klassenhierarchie ist wie folgt.

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

Java-Tupelklasse

Der Tupel ist eine abstrakte Basisklasse für alle Tupelklassen, zu denen sie gehört org.javatuples Paket. Alle Methoden der Tupelklasse sind öffentlich und endgültig. Die folgende Tabelle fasst die Methoden der Tupelklasse zusammen. Es implementiert iterierbare und serialisierbare Schnittstellen.

Direkt bekannte Unterklassen

Neben den oben genannten Klassen gibt es zwei zusätzliche Klassen, die von der Javatuples-Bibliothek bereitgestellt werden, d. h. Schlüsselwert Und LabelValue . Diese beiden Klassen ähneln der Paar Klasse und bieten die gleiche Funktionalität, jedoch in unterschiedlicher Semantik.

Jede Tupelklasse implementiert die folgenden drei Schnittstellen:

• Wiederholbar
• Vergleichbar
• Serialisierbar

Implementierung von Tuple

Die Implementierung eines Tupels in Java ist sehr einfach. Wir müssen eine Instanz der Tupelklasse erstellen, die der Größe entspricht.

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

Ausgabe:

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

Tupeloperationen

Die folgenden Operationen können für ein Tupel ausgeführt werden:

• Erstellen eines Tupels
• Werte gewinnen
• Werte einstellen
• Elemente hinzufügen
• Iteriere über Tuple
• Konvertieren Sie Tupel in eine Liste
• Suche in Tupel

Tupel erstellen

Es gibt drei Möglichkeiten, ein Tupel zu erstellen:

• Durch Verwendung der with()-Methode
• Mithilfe des Konstruktors
• Durch die Verwendung der Sammlung

Sehen wir uns die oben genannten drei Möglichkeiten zum Erstellen eines Tupels an.

Durch Verwendung der with()-Methode

Die Javatuples-Bibliothek stellt die bereit mit() Methode, die ein Tupel mit den angegebenen Werten erstellt. Die Methode gehört zur org.javatuples.Pair Paket. Es wird verwendet, um Objekte mit Werten zu instanziieren.

Syntax:

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

Beispiel:

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

Das obige Pair-Klassenobjekt erstellt ein Tupel mit zwei Werten. Lassen Sie uns dafür ein Java-Programm erstellen.

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

Ausgabe:

 [9086651, Dell Laptop] 

Mithilfe des Konstruktors

In diesem Fall erstellen wir je nach Anforderung einen Konstruktor der Klasse.

Syntax:

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

Beispiel:

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

Lassen Sie uns ein Java-Programm erstellen, um mithilfe des Konstruktors ein Tupel zu erstellen.

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

Ausgabe:

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

Durch die Verwendung der Sammlung

Mit der javatuples-Bibliothek können wir mithilfe von ein Tupel aus der Sammlung erstellen fromCollection() Methode. Es ermöglicht uns auch, mithilfe von ein Tupel aus einem Array zu erstellen fromArray() Methode. Beachten Sie, dass die Sammlung/das Array denselben Typ und dieselben Werte wie das Tupel haben muss.

Die Sammlung/das Array muss denselben Typ wie das Tupel haben und die Anzahl der Werte in der Sammlung/dem Array muss mit der Tupel-Klasse übereinstimmen.

Syntax:

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

Beispiel:

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

Ausgabe:

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

Holen Sie sich Werte

Mit der javatuples-Bibliothek können wir mithilfe von auch Werte aus dem Tupel am angegebenen Index abrufen getValueX() Methode. Wobei X den Indexwert des Objekts bezeichnet. Die Indizierung beginnt bei 0.

Beispiel:

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

Ausgabe:

 [Andrew] 

Werte festlegen

Wie wir oben besprochen haben, sind Tupel unveränderlich. Daher können sie nach ihrer Erstellung nicht mehr geändert werden. Um das Problem zu lösen, bietet die Javatuples-Bibliothek die setValueX() Methode. Wobei X der Indexwert ist, auf den wir den spezifischen Wert festlegen möchten. Die Methode erstellt eine Kopie des Tupels mit dem neu hinzugefügten Wert am angegebenen Index und gibt dasselbe Tupel zurück.

Beispiel:

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

Ausgabe:

 [67, 68] 

Einen Wert hinzufügen

Es gibt zwei Möglichkeiten, Werte in einem Tupel hinzuzufügen:

• Am Ende des Tupels
• Bei spezifischem Index

Am Ende des Tupels

Die Javatuples-Bibliothek stellt die bereit hinzufügen() Methode zum Hinzufügen von Objekten zum Tupel. Es fügt das Objekt am Ende des Tupels hinzu und gibt ein neues Tupel zurück, indem es die Anzahl der Elemente anpasst.

Angenommen, wir haben ein Tupel mit zwei Elementen und möchten dem Tupel ein weiteres Element hinzufügen. In einem solchen Fall unterstützt das Pair-Tupel das dritte Element nicht. Wenn wir also ein Element zu einem Paar-Tupel hinzufügen, wird es in ein Triplett-Tupel umgewandelt. Sehen wir uns ein Beispiel an.

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

Ausgabe:

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

Wir können auch ein Tupel zu einem anderen Tupel hinzufügen. Es erhöht die Anzahl der Elemente im neu generierten Tupel. Daher wird der Typ des Tupels basierend auf der Anzahl der nach der Hinzufügung vorhandenen Elemente zurückgegeben.

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

Ausgabe:

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

Am angegebenen Index

Standardmäßig werden neue Elemente am Ende des Tupels hinzugefügt. Wir können jedoch Elemente am angegebenen Index hinzufügen, indem wir die verwenden addX() Methode.

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

Ausgabe:

C++-String-Split

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

Suche nach einem Element

Wir können auch nach einem Element suchen, das sich im Tupel befindet. Für die Suche stellt die Javatuples-Bibliothek die zur Verfügung enthält() Methode der Tuple-Klasse. Es gibt einen booleschen Wert zurück WAHR Wenn ein Element vorhanden ist, wird else zurückgegeben FALSCH . Sehen wir uns ein Beispiel an.

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

Ausgabe:

 true false 

Konvertieren Sie Tupel in eine Sammlung oder ein Array

Jede Tupelklasse verfügt über die Methoden asList() und toArray(), die List bzw. Array zurückgeben. Sehen wir uns ein Beispiel an.

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

Ausgabe:

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

Beachten Sie, dass Tupel heterogene Typen enthalten können, sodass der resultierende Typ vom Typ ist Aufführen oder Objekt[] entsprechend.

Iteration über Tupel

Alle Tupelklassen implementieren das Wiederholbar Schnittstelle. Wir können ein Tupel also auf die gleiche Weise wie Sammlungen oder Arrays iterieren.

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

Ausgabe:

 Dell 5600.0 34 Digital Solutions 

Tupel vs. Liste/Array