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

Question

उनके बीच क्या अंतर है? मुझे पता है

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

लेकिन LinkedHashSet के सोर्सकोड में केवल HashSet के कॉलिंग कंस्ट्रक्टर हैं। तो डबल-लिस्टेड और इंसर्शन ऑर्डर कहाँ है?

Comments

उत्तर को ट्रैक करने के लिए Intellij (Ctrl + B) विकल्प का उपयोग करें। :)

— डेल्टा

बेशक आप स्रोत कोड संलग्न की जरूरत है। :)

— डेल्टा

Answer 1

उत्तर में निहित है कि निर्माणकर्ताLinkedHashSet आधार वर्ग के निर्माण के लिए उपयोग करता है:

public LinkedHashSet(int initialCapacity, float loadFactor) {
    super(initialCapacity, loadFactor, true);      // <-- boolean dummy argument
}

...

public LinkedHashSet(int initialCapacity) {
    super(initialCapacity, .75f, true);            // <-- boolean dummy argument
}

...

public LinkedHashSet() {
    super(16, .75f, true);                         // <-- boolean dummy argument
}

...

public LinkedHashSet(Collection<? extends E> c) {
    super(Math.max(2*c.size(), 11), .75f, true);   // <-- boolean dummy argument
    addAll(c);
}

और (एक उदाहरण) एक HashSetनिर्माता जो बूलियन तर्क लेता है, उसका वर्णन किया गया है, और इस तरह दिखता है:

/**
 * Constructs a new, empty linked hash set.  (This package private
 * constructor is only used by LinkedHashSet.) The backing
 * HashMap instance is a LinkedHashMap with the specified initial
 * capacity and the specified load factor.
 *
 * @param      initialCapacity   the initial capacity of the hash map
 * @param      loadFactor        the load factor of the hash map
 * @param      dummy             ignored (distinguishes this
 *             constructor from other int, float constructor.)
 * @throws     IllegalArgumentException if the initial capacity is less
 *             than zero, or if the load factor is nonpositive
 */
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
    map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);
}

Comments

स्पष्ट रूप से एक बच्चे की कक्षा के लिए कार्यक्षमता वाले एक अभिभावक वर्ग, जिसे भेद करने के लिए एक उपेक्षित तर्क है

— Traubenfuchs

कंस्ट्रक्टर डिसबिमग्रेशन के लिए डमी पैरामीटर का उपयोग करके बिल्कुल साफ डिजाइन नहीं।

— एरिक जे।

यह यथोचित स्वच्छ डिजाइन है, क्योंकि एपीआई स्वच्छ है (यह हैसेट कंस्ट्रक्टर पैकेज निजी है)। कक्षा के उपयोगकर्ताओं के लिए कार्यान्वयन का विवरण मायने नहीं रखता है। इस कोड को बनाए रखना कठिन हो सकता है, लेकिन java.util वर्गों के मामले में, यहां तक ​​कि बहुत छोटे प्रदर्शन सुधार भी इसे उचित ठहरा सकते हैं।

— lbalazscs

Answer 2

LinkedHashSetनिम्नलिखित आधार श्रेणी के निर्माणकर्ता को आमंत्रित करता है:

HashSet(int initialCapacity, float loadFactor, boolean dummy) {
  map = new LinkedHashMap<E, Object>(initialCapacity, loadFactor);
}

जैसा कि आप देख सकते हैं, आंतरिक नक्शा एक है LinkedHashMap। यदि आप अंदर देखते हैं LinkedHashMap, तो आपको निम्नलिखित फ़ील्ड की खोज होगी:

private transient Entry<K, V> header;

यह प्रश्न में लिंक की गई सूची है।

Answer 3

HashSet है अव्यवस्थित और अवर्गीकृत सेट।
LinkedHashSet HashSet का ऑर्डर किया गया संस्करण है।

HashSet और LinkedHashSet के बीच एकमात्र अंतर यह है कि:
LinkedHashSet प्रविष्टि क्रम को बनाए रखता है।

जब हम एक HashSet के माध्यम से पुनरावृत्ति करते हैं, तो यह अप्रत्याशित है, जबकि LinkedHetSet के मामले में यह अनुमान के अनुसार है ।

LinkedHashSet इंसर्शन ऑर्डर कैसे बनाए रखता है, इसका कारण यह है:
अंतर्निहित डेटा संरचना Doubly-Linked-List है ।

Answer 4

आप के स्रोत पर गौर करना चाहिए HashSetनिर्माता यह कहता है ... यह एक विशेष निर्माता है कि समर्थन बनाता है Mapएक LinkedHashMapके बजाय सिर्फ एक HashMap।

Comments

धन्यवाद, HashSet में LinkedHashMap बनाने के लिए कंस्ट्रक्टर है, जिसे LinkedHashSet में कहा जाता है और सभी तर्क LinkedHashMap में है

— Shikarn-O

Answer 5

मैं आपको LinkedHashSetज्यादातर समय का उपयोग करने का सुझाव देता हूं , क्योंकि इसका समग्र प्रदर्शन बेहतर है ):

1. उम्मीद के मुताबिक यात्रा के क्रम LinkedHashSet (Oracle)
2. लिंक्डहाशसेट, हैशसेट की तुलना में सम्मिलन के लिए अधिक महंगा है;
3. सामान्य रूप से थोड़ा बेहतर प्रदर्शन की तुलना में HashMap, क्योंकि अधिकांश समय हम पुनरावृति के लिए सेट संरचनाओं का उपयोग करते हैं।

प्रदर्शन जांच:

------------- TreeSet -------------
 size       add  contains   iterate
   10       746       173        89
  100       501       264        68
 1000       714       410        69
10000      1975       552        69
------------- HashSet -------------
 size       add  contains   iterate
   10       308        91        94
  100       178        75        73
 1000       216       110        72
10000       711       215       100
---------- LinkedHashSet ----------
 size       add  contains   iterate
   10       350        65        83
  100       270        74        55
 1000       303       111        54
10000      1615       256        58

आप स्रोत परीक्षण पृष्ठ यहां देख सकते हैं: अंतिम प्रदर्शन परीक्षण उदाहरण

Comments

मुझे उन "बेंचमार्क" से पहले जेवीएम का कोई वार्मिंग दिखाई नहीं देता, इसलिए मैं उस डेटा को गंभीरता से नहीं लेता। और पढ़ें

— फेलिक्स एस

Answer 6

हैशसेट: वास्तव में अनियंत्रित। अगर यू पैरामीटर पारित करने का मतलब है

Set<Integer> set=new HashSet<Integer>();
for(int i=0;i<set.length;i++)
{
  SOP(set)`enter code here`
}

आउट पुट: 2,1,3पूर्वानुमान नहीं हो सकता। अगली बार एक और आदेश

LinkedHashSet() जो फीफो ऑर्डर का उत्पादन करते हैं।

Answer 7

HashSet सम्मिलन आइटम का क्रम बनाए न रखें प्रविष्टि आइटम का क्रम
LinkedHashSet बनाए रखें

उदाहरण

Set<String> set = ...;// using new HashSet<>() OR new LinkedHashSet<>()
set.add("2");
set.add("1");
set.add("ab");
for(String value : set){
   System.out.println(value);
}  

HashSet उत्पादन

1
ab
2

LinkedHashSet उत्पादन

2
1
ab

Answer 8

HashSet:

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

HashSet में डुप्लिकेट की अनुमति नहीं है। यदि हम कोई संकलन या रनटाइम अपवाद नहीं प्राप्त करेंगे, तो उपयोगकर्ता डुप्लिकेट सम्मिलित करने का प्रयास कर रहे हैं। जोड़ें विधि रिटर्न केवल झूठ है।

कंस्ट्रक्टर्स:

HashSet h = new HashSet (); डिफ़ॉल्ट प्रारंभिक क्षमता 16 और डिफ़ॉल्ट भरण अनुपात (लोड फैक्टर) 0.75 के साथ एक खाली HashSet ऑब्जेक्ट बनाता है।

HashSet h = new HashSet (int initialCapacity); एक खाली HashSet ऑब्जेक्ट बनाता है जिसमें निर्दिष्ट इनिशैलिटी और डिफ़ॉल्ट भरण राशन 0.75 है।

HashSet h = new HashSet (int initialCapacity, float fillRatio);

HashSet h = new HashSet (संग्रह c); दिए गए संग्रह के लिए समतुल्य HashSet ऑब्जेक्ट बनाता है। यह कंस्ट्रक्टर संग्रह वस्तु के बीच अंतर रूपांतरण के लिए था।

LinkedHashSet:

यह हससेट का एक बच्चा वर्ग है। यह निम्न अंतरों को छोड़कर (कंस्ट्रक्टर्स और मेथड्स) सहित हैशसेट के समान है।

मतभेद हैशसेट:

1. रेखांकित डेटा संरचना हैशटेबल है।
2. सम्मिलन आदेश संरक्षित नहीं है।
3. 1.2 संस्करण पेश किया।

LinkedHashSet:

1. रेखांकित डेटा संरचना लिंक्डलिस्ट और हैशटेबल का एक संयोजन है।
2. सम्मिलन आदेश संरक्षित है।
3. 1.4 संस्करण में शामिल किया गया।

Answer 9

यदि आप LinkedHashSetक्लास से बुलाए गए कंस्ट्रक्टर्स पर एक नज़र डालते हैं, तो आप देखेंगे कि आंतरिक रूप से इसका LinkedHashMapउपयोग बैकिंग उद्देश्य के लिए किया जाता है।

Answer 10

सभी तरीके और निर्माता समान हैं लेकिन केवल एक अंतर है लिंक्डहैशसेट प्रविष्टि क्रम बनाए रखेगा लेकिन यह डुप्लिकेट की अनुमति नहीं देगा।

हैशसेट किसी भी प्रविष्टि क्रम को बनाए नहीं रखेगा। यह सूची और सेट सरल का संयोजन है :)