A tuple egy olyan adatstruktúra, amely különböző típusú objektumokat tartalmazhat. Ezek a tárgyak nem kapcsolódnak egymáshoz, de jelentésük van, ha együttesen tekintjük őket. Ebben a részben tárgyaljuk mi az a tuple , jellemzők, méret, és tevékenységek sorból. Továbbá megbeszéljük a tuple implementáció Java nyelven .

Mi az a tuple?

Általában véve a tuple tárgyak rendezett gyűjteménye. A sorban az adatok objektumként, külön bájttömbben tárolódnak. A vesszővel elválasztott értékeket szögletes zárójelben [] zárja. Tuples azok változhatatlan, ellentétben a Listák adatszerkezetével. Egy sor több sort is tartalmazhat. Anonim objektumnak is tekinthető.

A Tuple jellemzői

A Tuple a következő tulajdonságokkal rendelkezik:

• Ez típusbiztos, ismételhető, megváltoztathatatlan, és szerializálható .
• Megvalósítja a toString(), egyenlő(), és a hashCode()
• Egyben megvalósítja a Hasonló (Tuple eszközök összehasonlítható)

Tuple példa

Tekintsük a következő példát.

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

A fenti sor a kvartett tuple mert van négy elemek (tárgyak). Megfigyeljük, hogy minden objektum más típusú. De ha együttesen vesszük, akkor konkrét jelentése van. A fenti sor egy alkalmazott adatait reprezentálja, mint például a név, nem, életkor és megnevezés.

Lássunk néhány további példát a sorokra.

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

Tuple Java nyelven

A Java nyelvben a tuple egy általános adatstruktúra, amely minden elemet objektumként kezel, és ezek az objektumok külön bájttömbben tárolódnak. Más szóval azt is mondhatjuk, hogy a tuple egy elrendelte különböző típusú tárgyak gyűjteménye.

A Tuple funkcionalitása megvalósítható a Lista és Tömb adatszerkezettel, de ezek az adatstruktúrák tervezésüknél fogva nem tartalmaznak különböző típusú adattípusokat. Ezért egyértelmű, hogy heterogén Szabványos adatstruktúrát (List/Array) használó tuple nem lehetséges a Java-ban. Mivel megkívántuk tuple adatstruktúra a birtoklás követelményének teljesítéséhez homogén adatszerkezet.

Vegye figyelembe, hogy Tuple adatstruktúra nincs jelen a Java programozásban , alapértelmezés szerint. De megvalósíthatjuk a tuple adatstruktúrát a harmadik féltől származó nevű könyvtár használatával javatuples .

Mielőtt rátérnénk a megvalósításra, először letöltjük a javatuples.jar fájlt. És adja hozzá ezt a fájlt a projekt elérési útjához.

Használhatjuk a következő függőséget is pom.xml fájlt a tuples adatstruktúra megvalósításához Java nyelven.

 org.javatuples javatuples 1.2 

Valósítsunk meg egy tuple-t, és hozzunk létre egy egyszerű Java tuple programot.

Javatuples könyvtár

A javatuples könyvtárban vannak a tuple osztályok, amelyek megfelelnek egy tuple méretének. A szálak eltérő méretűek lehetnek. Egy sor legfeljebb 10 elemeket. Az egyes sorok megvalósítása eltérő. Az osztályhierarchia a következő.

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

Java Tuple Class

A Tuple egy absztrakt alaposztály az összes tuple osztályhoz, amelyhez tartozik org.javatuples csomag. A tuple osztály összes metódusa nyilvános és végleges. Az alábbi táblázat összefoglalja a tuple osztály metódusait. Iterálható és szerializálható felületeket valósít meg.

Közvetlen ismert alosztályok

A fenti osztályokon kívül két további osztályt is biztosít a javatuples könyvtár, azaz. Kulcs érték és LabelValue . Ez a két osztály hasonló a Pár osztályba, és ugyanazt a funkcionalitást biztosítják, de eltérő szemantikában.

Minden tuple osztály a következő három interfészt valósítja meg:

• Iterálható
• Hasonló
• Sorozatozható

A Tuple megvalósítása

A tuple implementálása Java nyelven nagyon egyszerű. Létre kell hoznunk egy példányt a tuple osztályból, amely megfelel a méretnek.

TuplePélda.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); } } 

Kimenet:

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

Tuple műveletek

A következő műveletek hajthatók végre egy soron:

• Tuple létrehozása
• Értékek megszerzése
• Értékek beállítása
• Elemek hozzáadása
• Iterálj a Tuple felett
• Konvertálja a Tuple-t listává
• Keresés a Tuple-ben

Tuple létrehozása

Háromféleképpen hozhat létre sorokat:

• A with() metódus használatával
• A Constructor használatával
• Gyűjtemény használatával

Lássuk a fenti három módszert egy sor létrehozására.

A with() metódus használatával

A javatuples könyvtár biztosítja a val vel() metódus, amely létrehoz egy tuple-t a megadott értékekkel. A módszer a org.javatuples.Pair csomag. Objektumok értékekkel történő példányosítására szolgál.

Szintaxis:

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

Példa:

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

A fenti Pair osztály objektum létrehoz egy tuple-t két értékkel. Ehhez készítsünk egy Java programot.

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

Kimenet:

java int karakterláncban

 [9086651, Dell Laptop] 

A Constructor használatával

Ebben az esetben igény szerint elkészítjük az osztály konstruktorát.

Szintaxis:

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

Példa:

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

Hozzunk létre egy Java programot, hogy létrehozzunk egy tuple-t a konstruktor segítségével.

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

Kimenet:

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

Gyűjtemény használatával

A javatuples könyvtár lehetővé teszi, hogy a gyűjteményből egy leírót hozzunk létre a fromCollection() módszer. Lehetővé teszi azt is, hogy egy tömbből leírót hozzunk létre a fromArray() módszer. Ne feledje, hogy a gyűjteménynek/tömbnek meg kell egyeznie a sor típusával és értékeivel.

A gyűjteménynek/tömbnek meg kell egyeznie a Tuple típusával, és a gyűjteményben/tömbben lévő értékek számának meg kell egyeznie a Tuple osztályával.

Szintaxis:

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

Példa:

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

Kimenet:

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

Szerezzen értékeket

A javatuples könyvtár azt is lehetővé teszi számunkra, hogy a megadott indexen lévő leíróból értékeket gyűjtsünk be a segítségével getValueX() módszer. Ahol X az objektum indexértékét jelöli. Az indexelés 0-tól kezdődik.

Példa:

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

Kimenet:

 [Andrew] 

Állítsa be az értékeket

Ahogy fentebb tárgyaltuk, a sorok megváltoztathatatlanok. Ezért létrehozásuk után nem módosíthatók. A probléma megoldása érdekében a javatuples könyvtár biztosítja a setValueX() módszer. Ahol X az az indexérték, amelynél az adott értéket be akarjuk állítani. A metódus létrehozza a leíró másolatát az újonnan hozzáadott értékkel a megadott indexen, és ugyanazt a leírót adja vissza.

Példa:

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

Kimenet:

elnevezési konvenció a java számára

 [67, 68] 

Érték hozzáadása

Kétféleképpen adhat hozzá értékeket egy sorhoz:

• A sor végén
• Egy adott indexen

A Tuple végén

A javatuples könyvtár biztosítja a add() metódus objektumok hozzáadásához a leíróhoz. Hozzáadja az objektumot a sor végéhez, és az elemek számának megfeleltetésével egy új sort ad vissza.

Tegyük fel, hogy van egy két elemű sorunk, és egy másik elemet szeretnénk hozzáadni a sorhoz. Ilyen esetben a pár sor nem támogatja a harmadik elemet. Ezért, ha egy elemet adunk egy pár sorhoz, az egy hármas sorrá alakul át. Lássunk egy példát.

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

Kimenet:

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

Hozzáadhatunk egy sort egy másik sorhoz is. Növeli az elemek számát az újonnan generált sorban. Ezért az összeadás után jelenlévő elemek száma alapján adja vissza a sor típusát.

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

Kimenet:

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

A megadott indexen

Alapértelmezés szerint az új elemek a sor végére kerülnek hozzáadásra. De a megadott indexhez hozzáadhatunk elemeket a addX() módszer.

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

Kimenet:

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

Elem keresése

Kereshetünk olyan elemet is, amely a sorban található. A javatuples könyvtár a kereséshez biztosítja a tartalmazza () a Tuple osztály metódusa. Logikai értéket ad vissza igaz ha egy elem jelen van, az else visszatér hamis . Lássunk egy példát.

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

Kimenet:

 true false 

Konvertálja a Tuple-t gyűjteménybe vagy tömbbe

Minden sorosztály rendelkezik asList() és toArray() metódusokkal, amelyek a List-et és az Array-t adják vissza. Lássunk egy példát.

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

Kimenet:

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

Vegye figyelembe, hogy a sor heterogén típusokat tartalmazhat, így a kapott típus a következő lesz Lista vagy Tárgy[] Eszerint.

Iteráció Tuple felett

Az összes tuple osztály megvalósítja a Iterálható felület. Tehát ugyanúgy iterálhatunk egy sort, mint a gyűjteményeket vagy a tömböket.

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

Kimenet:

 Dell 5600.0 34 Digital Solutions 

Tuple vs. Lista/tömb