א tuple הוא מבנה נתונים שיכול להחזיק אובייקטים מסוגים שונים. אובייקטים אלה אינם קשורים זה לזה, אך יש להם משמעות כאשר אנו רואים אותם באופן קולקטיבי. בחלק זה, אנו דנים מה זה טופל , תכונות, גודל, ו פעולות של tuples. כמו כן, נדון ב יישום tuple ב-Java .

מה זה טופל?

באופן כללי, א tuple הוא אוסף מסודר של חפצים. ב-tuple הנתונים מאוחסנים כאובייקט במערך בתים נפרד. יש לו ערכים מופרדים בפסיקים המוקפים בזוג סוגריים מרובעים []. Tuples הם בלתי ניתן לשינוי, בניגוד למבנה הנתונים של Lists. טאפל יכול להכיל טופלים מרובים. זה יכול להיחשב גם כאובייקט אנונימי.

תכונות של Tuple

ל- Tuple יש את התכונות הבאות:

זנב ג'אווה

• זה בטוח בדפוס, ניתן לחזור עליו, בלתי ניתן לשינוי, ו ניתן לסידרה .
• הוא מיישם את toString(), שווה(), ו ה-hashCode()
• זה גם מיישם את בר השוואה (מכשירי Tuple ניתנים להשוואה)

דוגמה טופל

הבה נבחן את הדוגמה הבאה.

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

הטפול לעיל הוא א רביעייה tuple כי יש לו ארבע אלמנטים (אובייקטים). אנו רואים שכל אובייקט הוא מסוג אחר. אבל כשאנחנו רואים את זה באופן קולקטיבי, יש לזה משמעות ספציפית. הטפול לעיל מייצג את הנתונים של עובד כגון שם, מין, גיל ויעוד.

בואו נראה עוד כמה דוגמאות של tuples.

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

Tuple בג'אווה

ב-Java, tuple הוא מבנה נתונים גנרי שמתייחס לכל אלמנט כאובייקט, ואובייקטים אלה מאחסנים במערך בתים נפרד. במילים אחרות, אנו יכולים גם לומר שטופל הוא an הורה אוסף חפצים מסוגים שונים.

ניתן ליישם את הפונקציונליות של tuple באמצעות מבנה הנתונים List ו-Array, אך מבני נתונים אלה אינם מכילים סוגים שונים של סוגי נתונים לפי תכנון. מכאן שברור ש הֵטֵרוֹגֵנִי tuple באמצעות מבנה נתונים סטנדרטי (List/ Array) אינו אפשרי ב-Java. מאז דרשנו tuple מבנה נתונים כדי למלא את דרישת ההחזקה הוֹמוֹגֵנִי מבנה נתונים.

ציין זאת מבנה הנתונים של tuple אינו קיים בתכנות Java , כברירת מחדל. אבל אנחנו יכולים ליישם את מבנה הנתונים tuple על ידי שימוש בספריית צד שלישי בשם javatuples .

לפני המעבר ליישום, ראשית, נוריד את ה javatuples.jar קוֹבֶץ. והוסיפו את הקובץ הזה לנתיב של הפרויקט.

אנחנו יכולים גם להשתמש בתלות הבאה ב pom.xml קובץ כדי ליישם את מבנה הנתונים tuples ב-Java.

 org.javatuples javatuples 1.2 

בואו ליישם tuple וליצור תוכנית Java tuple פשוטה.

ספריית Javatuples

ה javatuples בספרייה יש מחלקות tuple שמתאימות לגודל של tuple. גדלים עשויים להיות שונים בגודלם. tuple יכול להחזיק מקסימום של 10 אלמנטים. היישום של כל טופל שונה. היררכיית המעמדות היא כדלקמן.

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

כיתת Java Tuple

ה טופל הוא מחלקה בסיסית מופשטת לכל כיתות ה-tuple ששייכות אליה org.javatuples חֲבִילָה. כל השיטות של כיתת tuple הן ציבוריות וסופיות. הטבלה הבאה מסכמת את השיטות של מחלקת tuple. הוא מיישם ממשקים ל-Iterable ו-Serializable.

תת-כיתות ידועות ישירות

מלבד השיעורים הנ'ל, ישנם שני שיעורים נוספים הניתנים על ידי ספריית javatuples, כלומר. ערך מפתח ו LabelValue . שני השיעורים הללו דומים ל- זוג class ומספקים את אותה פונקציונליות אך בסמנטיקה שונה.

כל מחלקה tuple מיישמת את שלושת הממשקים הבאים:

• ניתן לחזרה
• בר השוואה
• ניתן להסדרה

יישום של Tuple

היישום של tuple ב-Java קל מאוד. עלינו ליצור מופע של tuple class התואם לגודל.

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

תְפוּקָה:

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

פעולות Tuple

ניתן לבצע את הפעולות הבאות בטופל:

• יצירת Tuple
• קבלת ערכים
• הגדרת ערכים
• הוספת אלמנטים
• חזור על Tuple
• המרת Tuple לרשימה
• מחפש ב- Tuple

יצירת Tuple

ישנן שלוש דרכים ליצור טופל:

• על ידי שימוש בשיטת with()
• באמצעות Constructor
• על ידי שימוש באוסף

בואו נראה את שלושת הדרכים לעיל ליצור טופל.

על ידי שימוש בשיטת with()

ספריית javatuples מספקת את עם() שיטה שיוצרת טופל עם הערכים שצוינו. השיטה שייכת ל- org.javatuples.Pair חֲבִילָה. הוא משמש לאינסטציה של אובייקטים עם ערכים.

תחביר:

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

דוגמא:

תור עדיפות c++

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

אובייקט המחלקה של Pair לעיל יוצר טופלה עם שני ערכים. בואו ניצור תוכנית Java עבור אותו הדבר.

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

תְפוּקָה:

 [9086651, Dell Laptop] 

באמצעות Constructor

במקרה זה, אנו יוצרים בנאי של המחלקה, בהתאם לדרישה.

תחביר:

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

דוגמא:

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

בואו ניצור תוכנית Java ליצירת tuple באמצעות בנאי.

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

תְפוּקָה:

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

על ידי שימוש באוסף

ספריית javatuples מאפשרת לנו ליצור tuple מהאוסף על ידי שימוש ב- fromCollection() שיטה. זה גם מאפשר לנו ליצור tuple ממערך באמצעות fromArray() שיטה. שימו לב שהאוסף/המערך חייבים להיות בעלי אותו סוג וערכים כמו ה-tuple.

האוסף/מערך חייב להיות זהה לסוג של Tuple ומספר הערכים באוסף/מערך חייב להתאים למחלקה Tuple.

תחביר:

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

דוגמא:

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

תְפוּקָה:

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

קבלו ערכים

ספריית javatuples מאפשרת לנו גם להביא ערכים מה-tuple באינדקס שצוין על ידי שימוש ב- getValueX() שיטה. כאשר X מציין את ערך האינדקס של האובייקט. הוספה לאינדקס מתחילה מ-0.

דוגמא:

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

תְפוּקָה:

 [Andrew] 

הגדר ערכים

כפי שדיברנו לעיל, tuples הם בלתי ניתנים לשינוי. לפיכך, לא ניתן לשנות אותם לאחר יצירתם. כדי להתגבר על הבעיה, ספריית javatuples מספקת את setValueX() שיטה. כאשר X הוא ערך האינדקס שבו אנו רוצים להגדיר את הערך הספציפי. השיטה יוצרת עותק של ה-tuple עם הערך המוסף החדש במדד שצוין ומחזירה את אותו tuple.

דוגמא:

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

תְפוּקָה:

 [67, 68] 

הוספת ערך

ישנן שתי דרכים להוסיף ערכים ב-tuple:

• בסוף הטפול
• באינדקס ספציפי

בסוף הטופלה

ספריית javatuples מספקת את לְהוֹסִיף() שיטה להוספת אובייקטים ל-tuple. הוא מוסיף את האובייקט בסוף ה-tuple ומחזיר tuple חדש על ידי התאמת מספר האלמנטים.

נניח, יש לנו טופל בעל שני אלמנטים ואנו רוצים להוסיף אלמנט נוסף לטופל. במקרה כזה, ה-Pair tuple לא יתמוך באלמנט השלישי. לכן, כאשר אנו מוסיפים אלמנט ל-Pair tuple, הוא הופך ל-Tuple טריפל. בואו נראה דוגמה.

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

תְפוּקָה:

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

אנחנו יכולים גם להוסיף טאפל אחד לטופל אחר. זה מגדיל את מספר האלמנטים ב-tuple החדש שנוצר. לפיכך, הוא מחזיר את סוג הטפול בהתבסס על מספר האלמנטים הקיימים לאחר ההוספה.

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

תְפוּקָה:

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

ב-Spified Index

כברירת מחדל, אלמנטים חדשים מתווספים בסוף ה-tuple. אבל אנחנו יכולים להוסיף אלמנטים באינדקס שצוין על ידי שימוש ב- addX() שיטה.

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

תְפוּקָה:

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

חיפוש אלמנט

אנחנו יכולים גם לחפש אלמנט שנמצא ב-tuple. לחיפוש ספריית javatuples מספקת את מכיל() שיטת מחלקת Tuple. זה מחזיר ערך בוליאני נָכוֹן אם קיים אלמנט, אחר חוזר שֶׁקֶר . בואו נראה דוגמה.

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

תְפוּקָה:

 true false 

המרת Tuple לאוסף או מערך

לכל מחלקה tuple יש שיטות asList() ו-toArray() שמחזירות רשימה ומערך, בהתאמה. בואו נראה דוגמה.

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

תְפוּקָה:

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

שימו לב ש-tuple יכול להכיל סוגים הטרוגניים ולכן הסוג שיתקבל יהיה של רשימה אוֹ לְהִתְנַגֵד[] בהתאם לכך.

יוניקס לעומת חלונות

איטרציה על טופלה

כל שיעורי tuple מיישמים את ניתן לחזרה מִמְשָׁק. אז, אנחנו יכולים לחזור על tuple באותו אופן כמו אוספים או מערכים.

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

תְפוּקָה:

 Dell 5600.0 34 Digital Solutions 

Tuple Vs. רשימה/מערך