CodeGym/Java Blog/अनियमित/जावा में लिंक्ड हैशसेट
John Squirrels
स्तर 41
San Francisco

जावा में लिंक्ड हैशसेट

अनियमित ग्रुप में प्रकाशित
सदस्य
Java में LinkedHashSet क्लास की बात करें तो हमें यह उल्लेख करना होगा कि यह सेट इंटरफ़ेस को लागू करता है। LinkedHashSet एक संग्रह बनाता है जो तत्वों को हैश तालिका में संग्रहीत करता है लेकिन इसके हैशसेट समकक्ष के विपरीत तत्वों के सम्मिलन क्रम को बनाए रखता है।

जावा में सेट क्या है

आइए हम संक्षेप में याद करें कि सेट इंटरफ़ेस एक सेट (सेट) को परिभाषित करता है। यह संग्रह का विस्तार करता है और संग्रह के व्यवहार को परिभाषित करता है जो डुप्लिकेट तत्वों की अनुमति नहीं देता है। इस प्रकार, यदि सेट में डुप्लिकेट तत्व जोड़ने का प्रयास किया जाता है, तो ऐड () विधि गलत होती है। इंटरफ़ेस स्वयं के किसी भी अतिरिक्त तरीके को परिभाषित नहीं करता है। सेट इंटरफ़ेस संग्रहीत वस्तुओं की विशिष्टता का ख्याल रखता है, विशिष्टता बराबर() विधि के कार्यान्वयन द्वारा निर्धारित की जाती है। इसलिए, यदि निर्मित वर्ग की वस्तुओं को सेट में जोड़ा जाएगा , तो बराबरी () विधि को ओवरराइड करना वांछनीय है ।

लिंक्ड हैशसेट क्लास

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

लिंक्ड हैशसेट की महत्वपूर्ण विशेषताएं

  • हम अद्वितीय तत्वों को केवल LinkedHashSet में संग्रहीत कर सकते हैं

  • LinketHashSet हमें तत्वों को उसी क्रम में निकालने देता है जिसमें हम सम्मिलित करते हैं

  • लिंक्ड हैशसेट सिंक्रोनाइज़ नहीं है

  • LinkedHashSet अशक्त तत्वों को संग्रहीत करने की अनुमति देता है

  • LinkedHashSet हैश कोड के आधार पर निर्दिष्ट इंडेक्स पर तत्वों को स्टोर करने के लिए हैशिंग तकनीक का उपयोग करता है

लिंक्ड हैशसेट तरीके

मूल वर्ग से विरासत में मिली विधियों के अलावा, हैशसेट निम्नलिखित विधियों को परिभाषित करता है:
  • बूलियन ऐड (ऑब्जेक्ट ओ) निर्दिष्ट तत्व को इस सेट में जोड़ता है यदि यह पहले से मौजूद नहीं है।

  • शून्य स्पष्ट () इस सेट से सभी तत्वों को हटा देता है।

  • ऑब्जेक्ट क्लोन () इस LinkedHashSet उदाहरण की उथली प्रति लौटाता है : तत्व स्वयं क्लोन नहीं होते हैं।

  • बूलियन सम्‍मिलित (ऑब्जेक्ट ओ) सही है यदि इस सेट में निर्दिष्ट तत्व शामिल है।

  • बूलियन isEmpty() सच हो जाता है अगर इस सेट में कोई तत्व नहीं है।

  • Iterator iterator() इस सेट के तत्वों पर एक पुनरावर्तक लौटाता है।

  • बूलियन रिमूव (ऑब्जेक्ट ओ) मौजूद होने पर इस सेट से निर्दिष्ट तत्व को हटा देता है।

  • int size() इस सेट में तत्वों की संख्या (इसके तत्वों की संख्या) लौटाता है।

आसान लिंक्ड हैशसेट उदाहरण नीचे दिए गए उदाहरण में हम लिंक्ड हैशसेट ऑब्जेक्ट का इनिशियलाइज़ेशन दिखाते हैं और सेट को भरने के लिए ऐड () विधि का उपयोग करते हैं।
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);
       }
   }
आउटपुट है:
[रे, डू, एफए, सोल, ला, टीआई, एमआई]
जैसा कि आप देख सकते हैं, हमारे सेट में तत्व उसी क्रम में दिखाई देते हैं जिसमें हमने उन्हें रखा था। जावा में लिंक्ड हैशसेट - 1

उदाहरण 2. 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);
       }
   }
कार्यक्रम का आउटपुट यहां है:
[रे, डू, एफए, सोल, ला, टीआई, एमआई]
उदाहरण दो का आउटपुट पहले उदाहरण के समान ही है। 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 LinkedHashMap का उपयोग करता है । यदि आपको सम्मिलन क्रम बनाए रखने की आवश्यकता नहीं है, लेकिन अद्वितीय वस्तुओं को संग्रहीत करने की आवश्यकता है, तो हैशसेट का उपयोग करना अधिक उपयुक्त है । यदि आपको तत्वों के सम्मिलन क्रम को बनाए रखने की आवश्यकता है तो LinkedHashSet आपकी पसंद है। LinkedHashSet का प्रदर्शन हैशसेट की तुलना में थोड़ा धीमा है क्योंकि 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);
   }
}
कार्यक्रम का आउटपुट है:
रेगुलर हैशसेट = [65536, 3, 5, 7, 9] लिंक्ड हैशसेट = [7, 3, 5, 65536, 9]

वास्तविक विश्व अनुप्रयोगों में Java 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 = [कुछ, तत्व, कुछ, डुप्लिकेट के साथ, यहाँ थे] लिंक्ड हैशसेट = [कुछ, तत्व, कुछ, डुप्लिकेट के साथ , थे, यहां] नियमित हैशसेट = [यहां, कुछ, डुप्लिकेट के साथ, थे, तत्व, कुछ]
टिप्पणियां
  • लोकप्रिय
  • नया
  • पुराना
टिप्पणी लिखने के लिए आपको साइन इन करना होगा
इस पेज पर अभी तक कोई टिप्पणियां नहीं हैं