CodeGym /Java Blog /यादृच्छिक /Java मध्ये LinkedHashSet
John Squirrels
पातळी 41
San Francisco

Java मध्ये LinkedHashSet

यादृच्छिक या ग्रुपमध्ये प्रकाशित केले
Java मधील LinkedHashSet क्लासबद्दल बोलताना , आम्हाला नमूद करणे आवश्यक आहे की ते सेट इंटरफेस लागू करते. LinkedHashSet एक संग्रह तयार करतो जो हॅश टेबलमध्ये घटक संग्रहित करतो परंतु त्याच्या HashSet समकक्षापेक्षा वेगळे घटक समाविष्ट करण्याचा क्रम राखतो.

Java मध्ये काय सेट आहे

आपण थोडक्यात लक्षात ठेवूया की सेट इंटरफेस सेट (सेट) परिभाषित करतो. हे संकलन विस्तारित करते आणि डुप्लिकेट घटकांना अनुमती न देणार्‍या संग्रहांचे वर्तन परिभाषित करते. अशा प्रकारे, सेटमध्ये डुप्लिकेट घटक जोडण्याचा प्रयत्न केल्यास add() पद्धत चुकीची दर्शवते. इंटरफेस स्वतःच्या कोणत्याही अतिरिक्त पद्धती परिभाषित करत नाही. सेट इंटरफेस संग्रहित वस्तूंच्या विशिष्टतेची काळजी घेतो, विशिष्टता equals() पद्धतीच्या अंमलबजावणीद्वारे निर्धारित केली जाते . म्हणून, जर तयार केलेल्या वर्गाच्या वस्तू सेटमध्ये जोडल्या गेल्या असतील तर , equals() पद्धत ओव्हरराइड करणे इष्ट आहे .

LinkedHashSet वर्ग

LinkedHashSet वर्गाबद्दल बोलण्यापूर्वी , आपण त्याच्या जवळच्या नातेवाईक, हॅशसेट वर्गाचा उल्लेख करणे आवश्यक आहे. हॅशसेट सेट इंटरफेस लागू करतो . हे एक संग्रह तयार करते जे घटकांना हॅश टेबलमध्ये संग्रहित करते. हॅश टेबलचे घटक की-व्हॅल्यू जोड्या म्हणून संग्रहित केले जातात. मूल्य संचयित करण्यासाठी की सेल (किंवा विभाग) निर्दिष्ट करते. हॅश कोड नावाचे अद्वितीय मूल्य निर्धारित करण्यासाठी कीची सामग्री वापरली जाते. आपण हॅश कोडला ऑब्जेक्ट आयडेंटिफायर म्हणून विचार करू शकतो, जरी तो अद्वितीय असणे आवश्यक नाही. हा हॅश कोड निर्देशांक म्हणून देखील काम करतो ज्यामध्ये कीशी संबंधित डेटा संग्रहित केला जातो. LinkedHashSet Java वर्ग कोणत्याही नवीन पद्धती न जोडता हॅशसेटचा विस्तार करतो.LinkedHashSet तुम्हाला HashSet प्रमाणेच एंट्रीचे अस्तित्व त्वरीत तपासण्याची परवानगी देतो , परंतु आत ऑर्डर केलेली यादी आहे. याचा अर्थ असा की ते घटकांचा अंतर्भूत क्रम संग्रहित करते. दुस-या शब्दात, LinkedHashSet सेट घटकांची लिंक केलेली सूची ते समाविष्ट केल्यानुसार ठेवते. हे सेटमध्ये समाविष्ट करण्याच्या क्रमाने पुनरावृत्ती करण्यास अनुमती देते. परंतु यामुळे LinkedHashSet क्लास हॅशसेट क्लासपेक्षा जास्त काळ ऑपरेशन करू शकतो .

LinkedHashSet ची महत्वाची वैशिष्ट्ये

  • आम्ही फक्त LinkedHashSet मध्ये अद्वितीय घटक संचयित करू शकतो

  • LinketHashSet आपण टाकतो त्याच क्रमाने घटक काढू

  • LinkedHashSet सिंक्रोनाइझ केलेले नाही

  • LinkedHashSet शून्य घटक संचयित करण्यास अनुमती देते

  • LinkedHashSet हॅश कोडवर आधारित निर्दिष्ट निर्देशांकावर घटक संचयित करण्यासाठी हॅशिंग तंत्र वापरते

LinkedHashSet पद्धती

त्याच्या पालक वर्गांकडून मिळालेल्या पद्धतींव्यतिरिक्त, हॅशसेट खालील पद्धती परिभाषित करते:
  • बूलियन अॅड(ऑब्जेक्ट ओ) या सेटमध्ये निर्दिष्ट घटक जोडतो जर तो आधीपासून उपस्थित नसेल.

  • void clear() या संचातील सर्व घटक काढून टाकते.

  • ऑब्जेक्ट क्लोन() या LinkedHashSet उदाहरणाची उथळ प्रत परत करते : घटक स्वतः क्लोन केलेले नाहीत.

  • जर या सेटमध्ये निर्दिष्ट घटक समाविष्ट असेल तर boolean contains(Object o) सत्य मिळवते.

  • या सेटमध्ये कोणतेही घटक नसल्यास boolean isEmpty() खरे मिळवते .

  • Iterator iterator() या संचाच्या घटकांवर पुनरावृत्ती करणारा परत करतो.

  • बुलियन रिमूव्ह (ऑब्जेक्ट ओ) या सेटमधून निर्दिष्ट घटक काढून टाकते, जर उपस्थित असेल.

  • 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]
जसे आपण पाहू शकता, आमच्या सेटमधील घटक त्याच क्रमाने दिसू लागले ज्यामध्ये आम्ही त्यांना ठेवले होते. Java मधील LinkedHashSet - १

उदाहरण 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]
उदाहरण दोनचे आउटपुट पहिल्या उदाहरणाप्रमाणेच आहे. आमच्याकडे 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] स्पष्ट आदेशानंतर आमचा संच मुद्रित करा: []
तुम्ही बघू शकता, अस्तित्वात नसलेल्या घटकावर लागू केलेल्या remove() पद्धतीमुळे प्रोग्राम त्रुटी होत नाही. जर घटक काढून टाकला नसेल तर तो खोटा आणि जर घटक LinkedHashSet मध्ये असेल आणि नंतर काढून टाकला असेल तर ते खरे दर्शवेल.

लिंक्डहॅशसेट वि हॅशसेट

हे दोन वर्ग जवळचे नातेवाईक आहेत. तथापि हॅशसेटच्या आत ते ऑब्जेक्ट्स संचयित करण्यासाठी हॅशमॅप वापरते तर LinkedHashSet LinkedHashMap वापरते . जर तुम्हाला इन्सर्शन ऑर्डर राखण्याची गरज नसेल परंतु युनिक ऑब्जेक्ट्स साठवण्याची गरज असेल, तर हॅशसेट वापरणे अधिक योग्य आहे . जर तुम्हाला घटकांचा समावेश क्रम राखायचा असेल तर 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);
   }
}
प्रोग्रामचे आउटपुट आहे:
नियमित हॅशसेट = [६५५३६, ३, ५, ७, ९] लिंक्डहॅशसेट = [७, ३, ५, ६५५३६, ९]

वास्तविक जगातील अनुप्रयोगांमध्ये 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 = [येथे, काही, सह, डुप्लिकेट, होते, घटक, काही]
टिप्पण्या
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION