אם כבר מדברים על מחלקת LinkedHashSet ב-Java, עלינו להזכיר שהיא מיישמת את ממשק ה- Set . LinkedHashSet יוצר אוסף המאחסן אלמנטים בטבלת גיבוב אך שומר על סדר ההכנסה של אלמנטים בניגוד למקבילו ל- HashSet .

מה מוגדר ב-Java

נזכיר בקצרה שממשק הסט מגדיר קבוצה (סט). הוא מרחיב את האוסף ומגדיר את ההתנהגות של אוספים שאינם מאפשרים רכיבים כפולים. לפיכך, המתודה add() מחזירה false אם נעשה ניסיון להוסיף רכיב כפול לסט. הממשק אינו מגדיר שיטות נוספות משלו. ממשק ה- Set דואג לייחודיות של אובייקטים מאוחסנים, הייחודיות נקבעת על ידי יישום שיטת equals() . לכן, אם אובייקטים של המחלקה שנוצרה יתווספו ל- Set , רצוי לעקוף את המתודה equals() .

מחלקה LinkedHashSet

לפני שנדבר על מחלקת LinkedHashSet , עלינו להזכיר את קרוב משפחתה, מחלקת HashSet . HashSet מיישמת את ממשק ה-Set . זה יוצר אוסף המאחסן את האלמנטים בטבלת hash. האלמנטים של טבלת hash מאוחסנים כזוגות מפתח-ערך. המפתח מציין את התא (או המקטע) לאחסון הערך. התוכן של המפתח משמש לקביעת ערך ייחודי הנקרא קוד hash. אנו יכולים לחשוב על קוד hash כמזהה אובייקט, למרות שהוא לא חייב להיות ייחודי. קוד חשיש זה משמש גם כאינדקס שאליו מאוחסנים הנתונים הקשורים למפתח. מחלקת LinkedHashSet Java מרחיבה את HashSet מבלי להוסיף מתודות חדשות. LinkedHashSet מאפשר לך לבדוק במהירות את קיומו של ערך, בדיוק כמו HashSet , אך מכיל בתוכו רשימה מסודרת. זה אומר שהוא מאחסן את סדר ההכנסה של האלמנטים. במילים אחרות, LinkedHashSet שומר על רשימה מקושרת של רכיבי סט בסדר שהם הוכנסו. זה מאפשר איטרציה מסודרת של הכנסה לתוך קבוצה. אבל זה גורם למחלקה LinkedHashSet לבצע פעולות ארוכות יותר ממחלקת HashSet .

תכונות חשובות של LinkedHashSet

  • אנו יכולים לאחסן אלמנטים ייחודיים רק ב- LinkedHashSet

  • LinketHashSet מאפשר לנו לחלץ אלמנטים באותו סדר שאנו מכניסים

  • LinkedHashSet אינו מסונכרן

  • LinkedHashSet מאפשר אחסון אלמנטים null

  • LinkedHashSet משתמש בטכניקת גיבוב כדי לאחסן אלמנטים באינדקס מוגדר בהתבסס על קוד גיבוב

שיטות LinkedHashSet

בנוסף לשיטות שעברו בירושה ממחלקות האב שלו, HashSet מגדיר את השיטות הבאות:

  • boolean add(Object o) מוסיף את האלמנט שצוין לקבוצה זו אם הוא עדיין לא קיים.

  • void clear() מסיר את כל הרכיבים מהקבוצה הזו.

  • Object clone() מחזיר עותק רדוד של מופע LinkedHashSet זה : האלמנטים עצמם אינם משובטים.

  • boolean contains(Object o) מחזירה true אם קבוצה זו מכילה את האלמנט שצוין.

  • boolean isEmpty() מחזירה true אם קבוצה זו אינה מכילה אלמנטים.

  • Iterator iterator() מחזיר איטרטור מעל הרכיבים של קבוצה זו.

  • boolean remove(Object o) מסיר את האלמנט שצוין מקבוצה זו, אם קיים.

  • int size() מחזירה את מספר האלמנטים בקבוצה זו (מספר האלמנטים שלה).

דוגמאות של Easy LinkedHashSet בדוגמה למטה אנו מראים אתחול של האובייקט LinkedHashSet ושימוש בשיטת add() למילוי הסט. 

import java.util.LinkedHashSet;
import java.util.Set;

   public class LinkedHashSetEx1 {
       public static void main(String[] args) {
//LinkedHashSet() Init            
Set<String> set = new LinkedHashSet<>();
//adding elements to LinkedHashSet 
           set.add("Re"); //first added element 
           set.add("Do");
           set.add("Fa");
           set.add("Sol");
           set.add("La");
           set.add("Ti");
           set.add("Mi");//last added element  


           System.out.println(set);
       }
   }
הפלט הוא:
[Re, Do, Fa, Sol, La, Ti, Mi]
כפי שאתה יכול לראות, האלמנטים בסט שלנו הופיעו באותו הסדר שבו הצבנו אותם. LinkedHashSet ב-Java - 1

דוגמה 2. הוספת כפיל לתוך LinkedHashSet

בואו נכניס שוב ל- LinkedHashSet שלנו 7 אלמנטים עם שמות של תווים מוזיקליים ונשים אלמנט אחד חדש זהה לאחד מהאלמנטים שהוצבו קודם לכן. 

import java.util.LinkedHashSet;
import java.util.Set;

public class LinkedHashSetEx2 {
   public static void main(String[] args) {
           Set<String> set = new LinkedHashSet<>();
           set.add("Re");
           set.add("Do");
           set.add("Fa");
           set.add("Sol");
           set.add("La");
           set.add("Ti");
           set.add("Mi");
           set.add("Sol");
           System.out.println(set);
       }
   }
הפלט של התוכנית נמצא כאן:
[Re, Do, Fa, Sol, La, Ti, Mi]
הפלט של דוגמה 2 זהה לחלוטין לזו שבדוגמה הראשונה. לא יכולים להיות לנו שני אלמנטים דומים באוסף LinkedHashSet . כשאנחנו מנסים לשים את השני, זה פשוט מתעלם.

דוגמה 3. הסרת אלמנטים מ-LinkedHashSet


import java.util.LinkedHashSet;
import java.util.Set;
   public class LinkedHashSet3 {
       public static void main(String[] args) {
           Set<String> set = new LinkedHashSet<>();
           set.add("Re");
           set.add("Do");
           set.add("Fa");
           set.add("Sol");
           set.add("La");
           set.add("Ti");
           set.add("Mi");
           System.out.println(set);
           set.remove("Fa");// removing an element from our set
           set.remove("Score");//trying to remove element that isn't in set
           System.out.println(set.remove("Score"));
           System.out.println("Print our set without elements removed: ");
           System.out.println(set);
           set.clear();
           System.out.println("Print out our set after clear command: ");
           System.out.println(set);
       }
   }
הפלט של התוכנית נמצא כאן:
[Re, Do, Fa, Sol, La, Ti, Mi] false הדפס את הסט שלנו ללא אלמנטים שהוסרו: [Re, Do, Sol, La, Ti, Mi] הדפס את הסט שלנו לאחר פקודה ברורה: []
כפי שאתה יכול לראות, שיטת remove() המוחלת על רכיב לא קיים אינה גורמת לשגיאת תוכנית. זה פשוט מחזיר false אם האלמנט לא הוסר ו- true אם האלמנט היה ב- LinkedHashSet ולאחר מכן הוסר.

LinkedHashSet לעומת HashSet

שני המעמדות הללו הם קרובי משפחה. אולם בתוך ה- HashSet הוא משתמש ב-HashMap כדי לאחסן אובייקטים בעוד LinkedHashSet משתמש ב- LinkedHashMap . אם אינך צריך לשמור על סדר ההכנסה אלא צריך לאחסן אובייקטים ייחודיים, עדיף להשתמש ב-HashSet . אם אתה צריך לשמור על סדר ההכנסה של אלמנטים אז LinkedHashSet היא הבחירה שלך. הביצועים של LinkedHashSet מעט איטיים יותר מ- HashSet מכיוון ש- LinkedHashSet משתמש ב-LinkedList פנימי כדי לשמור על סדר ההכנסה של אלמנטים. בוא נביא דוגמה: 

import java.util.*;

public class LinkedHashSetExample1 {

   public static void main(String[] args) {
       // while regular hash set orders its elements according to its hashcode stamps

       Set<Integer> regularHashSet = new HashSet<>();
       regularHashSet.add(7);
       regularHashSet.add(3);
       regularHashSet.add(5);
       regularHashSet.add(65536);
       regularHashSet.add(9);
       // few duplicates
       regularHashSet.add(5);
       regularHashSet.add(7);

       // next will print:
       // > regularHashSet = [65536, 3, 5, 7, 9]
       System.out.println("regularHashSet = " + regularHashSet);

       // linked hash set keeps order of adding unchanged

       Set<Integer> linkedHashSet = new LinkedHashSet<>();
       linkedHashSet.add(7);
       linkedHashSet.add(3);
       linkedHashSet.add(5);
       linkedHashSet.add(65536);
       linkedHashSet.add(9);
       // few duplicates
       linkedHashSet.add(5);
       linkedHashSet.add(7);

       // next will print:
       // > linkedHashSet = [7, 3, 5, 65536, 9]
       System.out.println("linkedHashSet = " + linkedHashSet);
   }
}
הפלט של התוכנית הוא:
regularHashSet = [65536, 3, 5, 7, 9] linkedHashSet = [7, 3, 5, 65536, 9]

שימוש ב-Java LinkedHashSet ביישומים בעולם האמיתי

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

import java.util.*;

class LinkedHashSetExample2 {
   public static void main(String[] args) {
       List<String> listWithDuplicates = List.of("some","elements","with", "few", "duplicates", "were", "here", "duplicates", "duplicates");

       Set<String> linkedHashSet = new LinkedHashSet<>(listWithDuplicates);
       List<String> listWithoutDuplicates = new ArrayList<>(linkedHashSet);

       // next will print:
       // > listWithDuplicates = [some, elements, with, few, duplicates, here, duplicates, duplicates]
       System.out.println("listWithDuplicates = " + listWithDuplicates);
       // next will print:
       // > listWithoutDuplicates = [some, elements, with, few, duplicates, here]
       System.out.println("listWithoutDuplicates = " + listWithoutDuplicates);

       // -------------------------------------------------------------------------

       // while using regular Hash Set will generally produces some unexpected order
       Set<String> regularHashSet = new HashSet<>(listWithDuplicates);

       // next will print:
       // > linkedHashSet = [some, elements, with, few, duplicates, were, here]
       System.out.println("linkedHashSet = " + linkedHashSet);
       // next will print:
       // > regularHashSet = [here, some, with, duplicates, were, elements, few]
       System.out.println("regularHashSet = " + regularHashSet);
   }
}
הפלט של התוכנית נמצא כאן:
listWithDuplicates = [חלקם, רכיבים, עם, מעט, כפילויות, היו, כאן, כפילויות, כפילויות] listWithoutDuplicates = [חלקם, רכיבים, עם, מעטים, כפילויות, היו, כאן] linkedHashSet = [חלקם, אלמנטים, עם, מעט, כפילויות , were, here] regularHashSet = [כאן, חלק, עם, כפילויות, היו, אלמנטים, מעטים]