מבוא ל- Javatuples

1. סקירה כללית

Tuple הוא אוסף של כמה אלמנטים שיכולים להיות קשורים זה לזה או לא. במילים אחרות, צמרות יכולות להיחשב לאובייקטים אנונימיים.

לדוגמא, ["זיכרון RAM", 16, "אסטרה"] הוא טופל המכיל שלושה אלמנטים.

במאמר זה, נסתכל במהירות על ספרייה פשוטה באמת המאפשרת לנו לעבוד עם מבני הנתונים מבוססי הטופל, בשם javatuples.

2. מובנה Javatuples שיעורים

ספרייה זו מספקת לנו עשרה שיעורים שונים שיספיקו לרוב הדרישות שלנו הקשורות לטופלים:

  • יחידה
  • זוג
  • שְׁלִישִׁיָה
  • רביעייה
  • חמישייה
  • שִׁשִׁיָה
  • שְׁבִיעִיָה
  • שְׁמִינִיָה
  • אניעד
  • עָשׂוֹר

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

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

3. הוספת תלות של Maven

בואו נוסיף את התלות של מייבן לשלנו pom.xml:

 org.javatuples javatuples 1.2 

אנא בדוק במאגר Central Maven את הגרסה האחרונה.

4. יצירת צמרות

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

זוג זוג = זוג חדש ("זוג", 55);

יש גם דרך פחות מילולית ואלגנטית מבחינה סמנטית ליצירת טופל:

שלישיית שלישייה = Triplet.with ("שלום", 23, 1.2);

אנחנו יכולים גם ליצור צינורות מ ניתן לנידון:

List listOfNames = Arrays.asList ("ג'ון", "איילה", "אן", "אלכס"); רביעיית רביעייה = Quartet.fromCollection (collectionOfNames);

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

עם זאת, אנו יכולים ליצור כפל של סדר נמוך יותר זוג או א שְׁלִישִׁיָה באמצעות האוסף שלעיל, על ידי ציון אינדקס התחלתי ב- fromIterable () שיטה:

Pair pairFromList = Pair.fromIterable (listOfNames, 2);

הקוד לעיל יביא ליצירת a זוג המכיל "אן"ו"אלכס“.

ניתן ליצור נוחות גם מכל מערך:

מחרוזת [] שמות = מחרוזת חדשה [] {"ג'ון", "איילה", "אן"}; Triplet triplet2 = Triplet.fromArray (שמות);

5. קבלת ערכים מצמדים

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

בואו ניצור רביעייה חדשה ונביא כמה ערכים:

רביעיית רביעייה = Quartet.with ("ג'ון", 72.5, 32, "1051 SW"); שם מחרוזת = quartet.getValue0 (); גיל שלם = quartet.getValue2 (); assertThat (שם) .isEqualTo ("ג'ון"); טוענים כי (גיל). isEqualTo (32);

כפי שאנו רואים, העמדה של "ג'ון"הוא אפס,"72.5הוא אחד וכן הלאה.

שים לב שה- getValueX () השיטות בטיחותיות. כלומר, אין צורך בליהוק.

אלטרנטיבה לכך היא getValue (int pos) שיטה. נדרש מיקום מבוסס אפס של האלמנט שייאסף. שיטה זו אינה בטוחה לסוגיה ומחייבת יציקה מפורשת:

רביעיית רביעייה = Quartet.with ("ג'ון", 72.5, 32, "1051 SW"); שם מחרוזת = (מחרוזת) quartet.getValue (0); גיל שלם = (שלם) רביעייה.גט-ערך (2); assertThat (שם) .isEqualTo ("ג'ון"); טוענים כי (גיל). isEqualTo (32);

שימו לב שהשיעורים ערך מפתח ו LabelValue יש את השיטות המתאימות שלהם getKey () / getValue () ו getLabel () / getValue ().

6. קביעת ערכים לטופלים

דומה ל getValueX (), לכל הכיתות ב javatuples יש setAtX () שיטות. שוב, איקס הוא מיקומים מבוססי אפס עבור האלמנט אותו אנו רוצים להגדיר:

זוג ג'ון = Pair.with ("ג'ון", 32); זוג אלכס = john.setAt0 ("אלכס"); assertThat (john.toString ()). isNotEqualTo (alex.toString ());

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

7. הוספה והסרה של אלמנטים מצמרות

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

זוג זוג 1 = Pair.with ("ג'ון", 32); שלישיה שלישייה 1 = pair1.add ("1051 SW"); assertThat (triplet1.contains ("john")); assertThat (triplet1.contains (32)); assertThat (triplet1.contains ("1051 SW"));

ברור מהדוגמה לעיל שהוספת אלמנט אחד ל- a זוג תיצור חדש שְׁלִישִׁיָה. באופן דומה, הוספת אלמנט אחד ל- a שְׁלִישִׁיָה תיצור חדש רביעייה.

הדוגמה לעיל מדגימה גם את השימוש ב- מכיל () השיטה המסופקת על ידי כל הכיתות ב javatuples. זוהי שיטה שימושית באמת לאימות אם הטופל כולל ערך נתון.

אפשר גם להוסיף כפולה אחת לאחרת באמצעות לְהוֹסִיף() שיטה:

זוג זוג 1 = Pair.with ("ג'ון", 32); זוג זוג 2 = Pair.with ("אלכס", 45); רביעיית רביעיית 2 = pair1.add (pair2); assertThat (quartet2.containsAll (pair1)); assertThat (quartet2.containsAll (pair2));

שימו לב לשימוש ב- מכיל את כל () שיטה. זה יחזור נָכוֹן אם כל האלמנטים של זוג 1 נוכחים ב רביעייה 2.

כברירת מחדל, ה- לְהוֹסִיף() השיטה מוסיפה את האלמנט כאלמנט אחרון של הטופל. עם זאת, ניתן להוסיף את האלמנט במיקום נתון באמצעות addAtX () שיטה, היכן איקס היא המיקום המבוסס על אפס בו אנו רוצים להוסיף את האלמנט:

זוג זוג 1 = Pair.with ("ג'ון", 32); שלישיה משולשת 2 = pair1.addAt1 ("1051 SW"); assertThat (triplet2.indexOf ("john")). isEqualTo (0); assertThat (triplet2.indexOf ("1051 SW")). isEqualTo (1); assertThat (triplet2.indexOf (32)). isEqualTo (2);

דוגמה זו מוסיפה את חוּט במצב 1, אשר מאומת על ידי ה- אינדקס של() שיטה. שימו לב להבדל לפי סדר הסוגים עבור זוג וה שְׁלִישִׁיָה אחרי השיחה ל addAt1 () שיחת שיטה.

אנו יכולים גם להוסיף מספר אלמנטים באמצעות כל אחד מהם לְהוֹסִיף() אוֹ addAtX () שיטות:

זוג זוג 1 = Pair.with ("ג'ון", 32); רביעיית רביעייה 1 = pair1.add ("אלכס", 45); assertThat (רביעייה 1. containsAll ("אלכס", "ג'ון", 32, 45));

על מנת להסיר אלמנט מהכפולה, אנו יכולים להשתמש ב- removeFromX () שיטה. שוב, איקס מציין את המיקום מבוסס האפס של האלמנט שיש להסיר:

זוג זוג 1 = Pair.with ("ג'ון", 32); יחידת יחידה = pair1.removeFrom0 (); assertThat (יחידה מכילה (32));

8. המרת צינורות ל רשימה / מערך

כבר ראינו כיצד להמיר a רשימה לטפל. בואו נראה עכשיו חם להמיר tuple ל- a רשימה:

רביעיית רביעייה = Quartet.with ("ג'ון", 72.5, 32, "1051 SW"); רשימת רשימות = רביעיית.לוליסט (); assertThat (list.size ()). isEqualTo (4);

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

לבסוף, בואו להמיר את הדולג למערך:

רביעיית רביעייה = Quartet.with ("ג'ון", 72.5, 32, "1051 SW"); אובייקט [] מערך = quartet.toArray (); assertThat (array.length) .isEqualTo (4);

ברור מספיק, ה toArray () שיטה תמיד מחזירה לְהִתְנַגֵד[].

9. מסקנה

במאמר זה בחנו את ספריית javatuples וצפינו בפשטותה. הוא מספק סמנטיקה אלגנטית והוא ממש קל לשימוש.

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