CodeGym /จาวาบล็อก /สุ่ม /LinkedHashSet ใน Java
John Squirrels
ระดับ
San Francisco

LinkedHashSet ใน Java

เผยแพร่ในกลุ่ม
เมื่อพูดถึง คลาส LinkedHashSetใน Java เราต้องพูดถึงว่ามันใช้อินเทอร์เฟซ Set LinkedHashSetสร้างคอลเลกชันที่เก็บองค์ประกอบในตารางแฮช แต่รักษาลำดับการแทรกขององค์ประกอบซึ่งแตกต่างจากHashSetคู่ ของมัน

การตั้งค่าใน Java คืออะไร

ให้เราจำสั้น ๆ ว่า ส่วนต่อประสาน ชุดกำหนดชุด (ชุด) มันขยายคอลเลกชันและกำหนดลักษณะการทำงานของคอลเลกชันที่ไม่อนุญาตให้มีองค์ประกอบที่ซ้ำกัน ดังนั้นเมธอดadd() จะส่งกลับ ค่าเท็จหากมีการพยายามเพิ่มองค์ประกอบที่ซ้ำกันในชุด อินเทอร์เฟซไม่ได้กำหนดวิธีการเพิ่มเติมของตัวเอง อิน เทอร์เฟ ซ Setจะดูแลความเป็นเอกลักษณ์ของวัตถุที่เก็บไว้ ความเป็นเอกลักษณ์ถูกกำหนดโดยการใช้วิธีการเท่ากับ () ดังนั้น ถ้าออบเจกต์ของคลาสที่สร้างขึ้นจะถูกเพิ่มเข้าไปในSetขอแนะนำให้แทนที่เมธอดเท่ากับ ()

คลาส LinkedHashSet

ก่อนที่จะพูดถึง คลาส LinkedHashSetเราต้องพูดถึงญาติสนิทของคลาสHashSet ก่อน HashSetใช้อินเทอร์เฟซ Set สร้างคอลเลกชันที่เก็บองค์ประกอบในตารางแฮช องค์ประกอบของตารางแฮชจะถูกเก็บไว้เป็นคู่ของคีย์-ค่า คีย์ระบุเซลล์ (หรือเซ็กเมนต์) เพื่อเก็บค่า เนื้อหาของคีย์ใช้เพื่อกำหนดค่าเฉพาะที่เรียกว่ารหัสแฮช เราอาจคิดว่ารหัสแฮชเป็นตัวระบุออบเจกต์ แม้ว่ารหัสนั้นจะไม่ซ้ำกันก็ตาม รหัสแฮชนี้ยังทำหน้าที่เป็นดัชนีที่เก็บข้อมูลที่เกี่ยวข้องกับคีย์ คลาส LinkedHashSet Java ขยายHashSet โดยไม่ ต้องเพิ่มเมธอดใหม่ใดๆLinkedHashSetช่วยให้คุณตรวจสอบการมีอยู่ของรายการได้อย่างรวดเร็ว เช่นเดียวกับHashSetแต่มีรายการสั่งซื้ออยู่ภายใน ซึ่งหมายความว่าจะเก็บลำดับการแทรกขององค์ประกอบ กล่าวอีกนัยหนึ่งLinkedHashSetจะรักษารายการที่เชื่อมโยงขององค์ประกอบชุดตามลำดับที่ถูกแทรก สิ่งนี้ทำให้สามารถทำซ้ำคำสั่งของการแทรกในชุด แต่สิ่งนี้ทำให้ คลาส LinkedHashSetดำเนินการนานกว่าคลาส HashSet

คุณสมบัติที่สำคัญของ LinkedHashSet

  • เราสามารถจัดเก็บองค์ประกอบเฉพาะในLinkedHashSet เท่านั้น

  • LinketHashSetให้เราแยกองค์ประกอบตามลำดับเดียวกับที่เราแทรก

  • LinkedHashSetไม่ซิงโครไนซ์

  • LinkedHashSetอนุญาตให้จัดเก็บองค์ประกอบ null

  • LinkedHashSetใช้เทคนิคการแฮชเพื่อจัดเก็บองค์ประกอบที่ดัชนีที่ระบุตามรหัสแฮช

วิธี LinkedHashSet

นอกจากเมธอดที่สืบทอดมาจากคลาสพาเรนต์แล้วHashSetยังกำหนดเมธอดต่อไปนี้:
  • การเพิ่มบูลีน (Object o)เพิ่มองค์ประกอบที่ระบุให้กับชุดนี้หากยังไม่มีอยู่

  • void clear()ลบองค์ประกอบทั้งหมดออกจากชุดนี้

  • Object clone()ส่งคืนสำเนาตื้นของ อินสแตนซ์ LinkedHashSet นี้ : องค์ประกอบไม่ได้ถูกโคลน

  • บูลีนมี (Object o)คืนค่าจริงหากชุดนี้มีองค์ประกอบที่ระบุ

  • บูลีน isEmpty()คืนค่าจริงหากชุดนี้ไม่มีองค์ประกอบ

  • Iterator iterator()ส่งกลับ iterator เหนือองค์ประกอบของชุดนี้

  • บูลีนลบ (Object o)ลบองค์ประกอบที่ระบุออกจากชุดนี้ ถ้ามี

  • int size()ส่งคืนจำนวนองค์ประกอบในชุดนี้ (จำนวนองค์ประกอบ)

ตัวอย่าง 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);
       }
   }
ผลลัพธ์คือ:
[เร, โด, ฟ้า, ซอล, ลา, ติ, มิ]
อย่างที่คุณเห็น องค์ประกอบในชุดของเราปรากฏในลำดับเดียวกับที่เราวางไว้ 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);
       }
   }
ผลลัพธ์ของโปรแกรมอยู่ที่นี่:
[เร, โด, ฟ้า, ซอล, ลา, ติ, มิ]
ผลลัพธ์ของตัวอย่างที่ 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] เท็จ พิมพ์ชุดของเราโดยไม่มีองค์ประกอบที่ถูกลบ: [Re, Do, Sol, La, Ti, Mi] พิมพ์ชุดของเราหลังจากคำสั่งที่ชัดเจน: []
อย่างที่คุณเห็น วิธี การลบ ()ที่ใช้กับองค์ประกอบที่ไม่มีอยู่จริงจะไม่ส่งผลให้เกิดข้อผิดพลาดของโปรแกรม มันจะคืน ค่าเท็จหากองค์ประกอบไม่ถูกลบและ เป็นจริงหากองค์ประกอบนั้นอยู่ใน 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] LinkHashSet = [7, 3, 5, 65536, 9]

การใช้ Java LinkedHashSet ในแอปพลิเคชันในโลกแห่งความเป็นจริง

เนื่องจาก LinkedHashSetช่วยให้คุณสามารถตรวจสอบการมีอยู่ของรายการและจัดเก็บคำสั่งซื้อได้อย่างรวดเร็ว การรวบรวมนี้จึงค่อนข้างสะดวกสำหรับการกำจัดรายการที่ซ้ำกันออกจากรายการ หรือตัวอย่างเช่น การแก้ปัญหา เช่น รายการล่าสุดที่เพิ่งเห็นในกระเป๋าของฉัน หรือจำเกมเช่น Pokemon Go ได้ไหม? LinkedHashSetสามารถจัดเก็บรายชื่อโปเกมอนที่คุณพบและลำดับที่พวกมันเจอบนเส้นทางของคุณ ในกรณีนี้ โปเกมอนที่ "ซ้ำ" จะไม่เพิ่มในรายการอีกต่อไป หรือตัวอย่างเช่น รายชื่อบอสตามระดับที่คุณเคยพบในเกมที่มีระดับ หรือประวัติศาสตร์ของการค้นพบร่างกายของจักรวาล ชุดแฮชที่เชื่อมโยงช่วยให้คุณตรวจสอบได้อย่างรวดเร็วว่ามี Space body อยู่ในรายการหรือไม่ และหากไม่มี ให้เพิ่มลงในรายการ ลองมาดูตัวอย่างการกำจัดรายการที่ซ้ำกัน

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 = [บาง องค์ประกอบ มี น้อย ซ้ำกัน ที่นี่] LinkHashSet = [บาง องค์ประกอบ มี น้อย ซ้ำกัน , เป็น, ที่นี่] RegularHashSet = [ที่นี่, บาง, มี, ซ้ำ, มี, องค์ประกอบ, น้อย]
ความคิดเห็น
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION