java - हैश मैप, लिंक्ड हैश मैप और ट्रीमैप के बीच का अंतर




map (10)

हैश मैप पुनरावृत्ति आदेश के बारे में बिल्कुल गारंटी नहीं देता है। जब नए तत्व जोड़े जाते हैं तो यह पूरी तरह से बदल सकता है (और होगा)। TreeMap उनकी तुलना के अनुसार चाबियों के "प्राकृतिक क्रम" के अनुसार पुनरावृत्ति करेगा () विधि (या एक बाहरी रूप से आपूर्ति तुलनात्मक)। इसके अतिरिक्त, यह सॉर्टेड मैप इंटरफेस लागू करता है, जिसमें इस तरह के ऑर्डर पर निर्भर विधियां होती हैं। LinkedHashMap उस क्रम में पुन: सक्रिय होगा जिसमें प्रविष्टियों को मानचित्र में रखा गया था

देखो कि प्रदर्शन कैसे भिन्न है ..

वृक्ष नक्शा जो सॉर्ट किए गए मानचित्र का कार्यान्वयन है। डाल की जटिलता, प्राप्त करें और शामिल है प्राकृतिक ऑपरेशन के कारण मेरा ऑपरेशन ओ (लॉग एन) है

जावा में LinkedHashMap , LinkedHashMap और LinkedHashMap बीच क्या अंतर है? मुझे आउटपुट में कोई फर्क नहीं पड़ता क्योंकि सभी तीनों में keySet और valuesHashtable क्या हैं?

Map m1 = new HashMap();
m1.put("map", "HashMap");
m1.put("schildt", "java2");
m1.put("mathew", "Hyden");
m1.put("schildt", "java2s");
print(m1.keySet()); 
print(m1.values()); 

SortedMap sm = new TreeMap();
sm.put("map", "TreeMap");
sm.put("schildt", "java2");
sm.put("mathew", "Hyden");
sm.put("schildt", "java2s");
print(sm.keySet()); 
print(sm.values());

LinkedHashMap lm = new LinkedHashMap();
lm.put("map", "LinkedHashMap");
lm.put("schildt", "java2");
lm.put("mathew", "Hyden");
lm.put("schildt", "java2s");
print(lm.keySet()); 
print(lm.values());

हैश मैप

  • इसमें जोड़ी मान हैं (कुंजी, मूल्य)
  • कोई डुप्लिकेशन कुंजी मान नहीं
  • unordered unsorted
  • यह एक शून्य कुंजी और एक से अधिक शून्य मानों की अनुमति देता है

हैश टेबल

  • हैश मानचित्र के समान
  • यह शून्य कुंजी और शून्य मानों की अनुमति नहीं देता है

LinkedHashMap

  • यह मानचित्र कार्यान्वयन के संस्करण का आदेश दिया गया है
  • लिंक्ड सूची और हैशिंग डेटा संरचनाओं के आधार पर

ट्री-मैप

  • आदेश दिया गया और क्रमबद्ध संस्करण
  • हैशिंग डेटा संरचनाओं के आधार पर

देखें कि प्रत्येक वर्ग कक्षा आरेखण में निम्न आरेख ( बड़ा एक ) में कहां है। SortedMap और SortedMap लागू करता है जबकि SortedMap नहीं करता है।

HashTable अप्रचलित है और संबंधित ConcurrentHashMap वर्ग का उपयोग किया जाना चाहिए।


नक्शे के साथ अपने अनुभव से बस कुछ और इनपुट, जब मैं प्रत्येक का उपयोग करता हूं:

  • हैश मैप - सर्वोत्तम प्रदर्शन (तेज़) कार्यान्वयन की तलाश करते समय सबसे उपयोगी।
  • TreeMap (SortedMap इंटरफ़ेस) - सबसे उपयोगी जब मैं किसी विशेष क्रम में कुंजी को क्रमबद्ध या पुन: सक्रिय करने में सक्षम होने के साथ चिंतित हूं।
  • LinkedHashMap - TreeMap को बनाए रखने की बढ़ी हुई लागत के बिना TreeMap से गारंटीकृत ऑर्डरिंग के फायदे को जोड़ता है। (यह हैश मैप के जितना तेज़ है)। विशेष रूप से, LinkedHashMap removeEldestEntry() विधि को ओवरराइड करके कैश ऑब्जेक्ट बनाने के लिए एक शानदार प्रारंभिक बिंदु भी प्रदान करता है। यह आपको कैश ऑब्जेक्ट बनाने देता है जो आपके द्वारा परिभाषित कुछ मानदंडों का उपयोग करके डेटा समाप्त कर सकता है।

मैं दृश्य प्रस्तुति पसंद करते हैं:

╔══════════════╦═════════════════════╦═══════════════════╦═════════════════════╗
║   Property   ║       HashMap       ║      TreeMap      ║     LinkedHashMap   ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║ Iteration    ║  no guarantee order ║ sorted according  ║                     ║
║   Order      ║ will remain constant║ to the natural    ║    insertion-order  ║
║              ║      over time      ║    ordering       ║                     ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║  Get/put     ║                     ║                   ║                     ║
║   remove     ║         O(1)        ║      O(log(n))    ║         O(1)        ║
║ containsKey  ║                     ║                   ║                     ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║              ║                     ║   NavigableMap    ║                     ║
║  Interfaces  ║         Map         ║       Map         ║         Map         ║
║              ║                     ║    SortedMap      ║                     ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║              ║                     ║                   ║                     ║
║     Null     ║       allowed       ║    only values    ║       allowed       ║
║ values/keys  ║                     ║                   ║                     ║
╠══════════════╬═════════════════════╩═══════════════════╩═════════════════════╣
║              ║   Fail-fast behavior of an iterator cannot be guaranteed      ║
║   Fail-fast  ║ impossible to make any hard guarantees in the presence of     ║
║   behavior   ║           unsynchronized concurrent modification              ║
╠══════════════╬═════════════════════╦═══════════════════╦═════════════════════╣
║              ║                     ║                   ║                     ║
║Implementation║      buckets        ║   Red-Black Tree  ║    double-linked    ║
║              ║                     ║                   ║       buckets       ║
╠══════════════╬═════════════════════╩═══════════════════╩═════════════════════╣
║      Is      ║                                                               ║
║ synchronized ║              implementation is not synchronized               ║
╚══════════════╩═══════════════════════════════════════════════════════════════╝

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

विवरण के लिए LinkedHashMap , LinkedHashMap , LinkedHashMap


सभी तीन अनन्य कुंजी से मानों तक मैपिंग का प्रतिनिधित्व करते हैं, और इसलिए Map इंटरफ़ेस को लागू करते हैं।

  1. hashing मैप चाबियों के hashing पर आधारित एक नक्शा है। यह ओ (1) प्राप्त / रखरखाव संचालन का समर्थन करता है। काम करने के लिए कुंजी के पास hashCode() और equals() के निरंतर कार्यान्वयन होना चाहिए।

  2. LinkedHashMap हैश मैप के समान है, लेकिन यह उस क्रम में जागरूकता को जोड़ता है जिस पर आइटम जोड़े जाते हैं (या एक्सेस किया जाता है), इसलिए पुनरावृत्ति आदेश सम्मिलन आदेश (या निर्माण पैरामीटर के आधार पर एक्सेस ऑर्डर) के समान होता है।

  3. TreeMap एक पेड़ आधारित मैपिंग है। इसके डाल / प्राप्त संचालन ओ (लॉग एन) समय लेते हैं। इसके लिए तुलनात्मक या तुलनात्मक के साथ वस्तुओं की कुछ तुलनात्मक तंत्र की आवश्यकता होती है। पुनरावृत्ति आदेश इस तंत्र द्वारा निर्धारित किया जाता है।


सभी तीन वर्ग LinkedHashMap मैप, LinkedHashMap और LinkedHashMap java.util.Map इंटरफ़ेस लागू करता है, और अद्वितीय कुंजी से मानों को मैपिंग का प्रतिनिधित्व करता है।

HashMap

  1. एक HashMap में कुंजी के आधार पर मान होते हैं।

  2. इसमें केवल अद्वितीय तत्व हैं।

  3. इसमें एक शून्य कुंजी और एकाधिक शून्य मान हो सकते हैं।

  4. यह कोई आदेश बनाए रखता है।

    public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable

LinkedHashMap

  1. एक LinkedHashMap कुंजी के आधार पर मान शामिल है।
  2. इसमें केवल अद्वितीय तत्व हैं।
  3. इसमें एक शून्य कुंजी और एकाधिक शून्य मान हो सकते हैं।
  4. यह हैश मैप के समान है प्रविष्टि आदेश को बनाए रखता है// नीचे वर्ग मंदी देखें

    public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>

TreeMap

  1. एक TreeMap में कुंजी के आधार पर मान होते हैं। यह NavigableMap इंटरफेस लागू करता है और सार मैप कक्षा बढ़ाता है।
  2. इसमें केवल अद्वितीय तत्व हैं।
  3. इसमें शून्य कुंजी नहीं हो सकती है लेकिन इसमें कई शून्य मान हो सकते हैं।
  4. यह HashMap समान है आरोही क्रम को बनाए रखता है (इसकी कुंजी के प्राकृतिक क्रम का उपयोग करके क्रमबद्ध)।

    public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, Serializable

Hashtable

  1. एक हैशटेबल सूची की एक सरणी है। प्रत्येक सूची को बाल्टी के रूप में जाना जाता है। बाल्टी की स्थिति हैशकोड () विधि को कॉल करके पहचाना जाता है। एक हैशटेबल में कुंजी के आधार पर मान होते हैं।
  2. इसमें केवल अद्वितीय तत्व हैं।
  3. इसमें कोई शून्य या मूल्य नहीं हो सकता है।
  4. यह सिंक्रनाइज़ है
  5. यह एक विरासत वर्ग है।

    public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, Serializable

रेफरी: http://javarevisited.blogspot.in/2015/08/difference-between-HashMap-vs-TreeMap-vs-LinkedHashMap-Java.html


हैश नक्शा सम्मिलन आदेश को संरक्षित नहीं करता है।
उदाहरण। हैशमैप यदि आप कुंजी को सम्मिलित कर रहे हैं

1  3
5  9
4   6
7   15
3   10

यह इसे स्टोर कर सकता है

4  6
5  9
3  10
1  3
7  15

लिंक्ड हैशमैप सम्मिलन आदेश को संरक्षित करता है।

उदाहरण।
यदि आप कुंजी डाल रहे हैं

1  3
5  9
4   6
7   15
3   10

यह इसे स्टोर करेगा

1  3
5  9
4   6
7   15
3   10

जैसा कि हम सम्मिलित करते हैं।

वृक्ष नक्शा बढ़ते क्रम की कुंजी में वैल स्टोर करता है। उदाहरण।
यदि आप कुंजी डाल रहे हैं

1  3
5  9
4   6
7   15
3   10

यह इसे स्टोर करेगा

1  3
3  10
4   6
5   9
7   15

हैश मैप और ट्रीमैप के बीच प्रमुख अंतर हैं

  1. हैश मैप किसी भी ऑर्डर को बनाए रखता नहीं है। दूसरे शब्दों में, हैश मैप कोई गारंटी नहीं देता है कि पहले डाला गया तत्व पहले मुद्रित किया जाएगा, जहां ट्रीसेट की तरह ही, TreeMap तत्वों को इसके तत्वों के प्राकृतिक क्रम के अनुसार क्रमबद्ध किया जाता है

  2. आंतरिक हैश मैप कार्यान्वयन का उपयोग हैशिंग और ट्रीमैप आंतरिक रूप से लाल-काले पेड़ कार्यान्वयन का उपयोग करता है।

  3. हैश मैप एक नल कुंजी और कई शून्य मानों को स्टोर कर सकता है। ट्रीमैप में नल कुंजियां नहीं हो सकती हैं लेकिन इसमें कई शून्य मान हो सकते हैं।

  4. हैश मैप मूल संचालन के लिए निरंतर समय प्रदर्शन लेता है जैसे कि ओ (1)। ओरेकल दस्तावेज़ों के अनुसार, ट्रीमैप प्राप्त करने और विधि के लिए गारंटीकृत लॉग (एन) समय लागत प्रदान करता है।

  5. हैश मैप ट्रीमैप की तुलना में बहुत तेज़ है, क्योंकि हैश मैप का प्रदर्शन समय अधिकांश परिचालनों के लिए लॉग टाइम ट्रीमैप के खिलाफ स्थिर है।

  6. हैश मैप तुलनात्मक रूप से बराबर () विधि का उपयोग करता है जबकि ट्रीएप ऑर्डर को बनाए रखने के लिए तुलना () विधि का उपयोग करता है।

  7. हैश मैप नक्शा इंटरफ़ेस लागू करता है जबकि TreeMap NavigableMap इंटरफ़ेस लागू करता है।





map