HashMap, LinkedHashMap और TreeMap के बीच अंतर

Question

बीच क्या अंतर है HashMap, LinkedHashMapऔर TreeMapजावा में? मुझे आउटपुट में कोई अंतर नहीं दिखता है क्योंकि तीनों में है keySetऔर values। क्या हैं Hashtable?

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());

Answer 1

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

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

"हैशटेबल" हैश-आधारित मानचित्रों का सामान्य नाम है। जावा एपीआई के संदर्भ में, Hashtableसंग्रह ढांचे के अस्तित्व में आने से पहले जावा 1.1 के दिनों से एक अप्रचलित वर्ग है। इसका अब उपयोग नहीं किया जाना चाहिए, क्योंकि इसकी एपीआई अप्रचलित तरीकों से बरबाद होती है जो कि कार्यक्षमता की नकल करते हैं, और इसके तरीके सिंक्रनाइज़ किए जाते हैं (जो प्रदर्शन को कम कर सकते हैं और आमतौर पर बेकार है)। हैशटेबल के बजाय समवर्ती हाशपा का उपयोग करें ।

Comments

फिर मैप वास्तव में क्या है और मैप, हैशपे और हैशटेबल्स के बीच अंतर क्या है।

— केविन

@ अन्य: मानचित्र एक इंटरफ़ेस है। HashMap और Hashtable दोनों इसे लागू करते हैं; जैसा कि मैंने लिखा, हैशटेब एक विरासत वर्ग है।

— माइकल बोर्गवर्ड

के बीच एक उल्लेखनीय अंतर Hashtableऔर HashMapएक Hashtable में, "न तो कुंजी है और न ही मान शून्य हो सकता है" है। यह बाधा उत्तरार्द्ध में मौजूद नहीं है।

— aioobe

@AshkanN: हाँ - वास्तव में वे छँटाई को लागू करने के मानक तरीके हैं। ट्री मैप में एक कंस्ट्रक्टर है जो उपयोग करने के लिए एक तुलनित्र लेता है, और यदि कोई नहीं प्रदान किया जाता है, तो यह अपेक्षा करता है कि सभी वस्तुओं को तुलनीय लागू करने के लिए जोड़ा जाए।

— माइकल बोर्गवर्ड

आप यह चुन सकते हैं कि आप प्रविष्टि-क्रम या पहुँच-क्रम में LinkedHashMap पुनरावृत्ति चाहते हैं या नहीं।

— lbalazscs

Answer 2

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

╔══════════════╦═════════════════════╦═══════════════════╦═════════════════════╗
║   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               ║
╚══════════════╩═══════════════════════════════════════════════════════════════╝

Comments

सम्मिलन-आदेश के अलावा, लिंक्डहाशपैप भी एक्सेस-ऑर्डर (बूलियन एक्सेस-ऑर्डर परम के साथ कंस्ट्रक्टर का उपयोग करते समय) का समर्थन करता है।

— ईयाल श्नाइडर

डबल लिंक्ड बाल्टी? मुझे लगता है कि सम्मिलन / हटाने के संचालन के लिए बाल्टी की खोज करने के लिए अनावश्यक ओवरहेड जोड़ता है (क्योंकि इसमें वस्तु डालने के लिए सही बाल्टी की खोज करनी है)। मैंने हमेशा सोचा था कि लिंक्डहाशप कार्यान्वयन एक मैप के समान होगा लेकिन "एंट्री लिस्ट" के थोड़े अतिरिक्त ओवरहेड के साथ (लिंक की गई सूची के रूप में हो सकता है) जो कि इटर्शन उद्देश्यों के लिए उपयोग किया जाता है। क्या आप निश्चित हैं, शेवचुक? यदि हां, तो क्या आप मुझे कुछ ऑनलाइन लिंक समझा सकते हैं या दे सकते हैं जो आपके बयान को वापस कर सकते हैं?

— साई डबका Sai

@SaiDubbaka LinkedHashMap के पास डबल लिंक की गई बाल्टी है, लेकिन बाल्टी टेबल हाशप के पास भी है। यह इसकी जगह नहीं है। इसका मतलब यह है कि एक्सेस बकेट उसी तरह से किया जाता है जैसे हाशप में, क्योंकि लिंक्डइन ऑर्डर (या एक्सेस ऑर्डर) में पुनरावृत्ति के लिए लिंक की गई सूची है।

— गेरार्डो लास्ट्रा

यह ध्यान देने योग्य हो सकता है, कि O (1) सबसे अच्छा मामला परिदृश्य है (जिसे हम आमतौर पर O नहीं कहेंगे, यह प्रश्न देखें )

— सेबस्टियन S

यह भी ध्यान देने योग्य है कि ओ (1) हमेशा ओ (लॉग एन) से बेहतर नहीं है; यदि आपके पास एक बहुत लंबी कुंजी है, तो BST पर आधारित कुछ उस चीज़ की तुलना में बहुत तेज़ हो सकता है, जिसे कुछ भी करने में सक्षम होने से पहले पूरी कुंजी पर O (n) हैश करना है।

— निधि मोनिका का मुकदमा

Answer 3

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

1. हैशपॉप , चाबियों के हैशिंग के आधार पर एक नक्शा है । यह O (1) get / put संचालन का समर्थन करता है। कुंजी में काम करने के लिए और इसके लिए लगातार कार्यान्वयनhashCode()equals() होना चाहिए ।

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

3. ट्रीपैप एक ट्री बेस्ड मैपिंग है। इसके पुट / ऑपरेशंस में O (लॉग एन) समय लगता है। इसके लिए कुछ तुलना तंत्र की आवश्यकता होती है, या तो तुलनीय या तुलनात्मक। पुनरावृत्ति क्रम इस तंत्र द्वारा निर्धारित किया जाता है।

Comments

इसलिए अगर मैं सही ढंग से समझूं, तो लिंक्डहैशपैम और ट्रीपेज़ के बीच एकमात्र अंतर प्रदर्शन है, यह देखते हुए कि सम्मिलन का क्रम प्राकृतिक आदेश के समान है?

— मोशे शाहम

@MosheShaham जैसा कि उन्होंने # 2 में कहा: LinkedHashMapसम्मिलन क्रम में पुनरावृत्ति होगी, प्राकृतिक आदेश नहीं। तो अगर आप जोड़ने के (2,5,3)एक करने के लिए LinkedHashMapइस पर प्रत्येक के लिए और एक करते हैं, यह वापस आ जाएगी 2,5,3। यदि यह थे 2,5,3एक करने के लिए TreeMapवापस कर देंगे 2,3,5।

— ग्रिंच

ट्री मैप में कई अन्य अच्छी ट्रिक्स भी हैं। जैसे सिर और पूंछ का नक्शा।

— थॉमस अहले

निजी ट्रीपैप <string, Integer> mySection2 = new TreeMap <> (); mySection2.put ("abc1", 2); mySection2.put ( "ABC2", 5); mySection2.put ( "abc3", 3); के लिए (पूर्णांक x: mySection2.values ​​()) {Log.e ("लॉग", "ट्रीपेज़ ====" + x); } यह मुझे वही आदेश दे रहा है जैसे आइटम डाले गए थे? कृपया सुझाव दें कि यह LinkedHashMaps से कैसे भिन्न है?

— बृषि

@ बी.श्रुति: ऐसा इसलिए है क्योंकि आपका सम्मिलन क्रम आपकी कुंजियों ("abc1", "abc2", "abc3") के लेक्सोग्राफ़िक क्रम से मेल खाता है। यदि आप एक अलग क्रम में सम्मिलित करते हैं, तो आपका कोड अभी भी लेक्सिकोग्राफ़िक क्रम के अनुसार पुनरावृत्त होगा।

— इल श्नाइडर

Answer 4

देखें कि प्रत्येक वर्ग निम्न चित्र में वर्ग पदानुक्रम में कहां है ( बड़ा एक )। ट्री-मैप लागू करता SortedMapहै और NavigableMapजबकि HashMapऐसा नहीं करता।

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

Answer 5

हैश मैप

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

हैश टेबल

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

LinkedHashMap

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

ट्री-मैप

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

Comments

इसके अलावा हैशटेबल सिंक्रनाइज़ है। वैसे भी, मुझे आपका जवाब पसंद है, साफ और स्पष्ट।

— सुरसिन तन्खारोएन

Answer 6

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

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

Comments

सटीक होने के लिए, TreeMap तत्वों को क्रम में नहीं रखता है। यह चाबियों को क्रम में रखता है।

— एलएस

Answer 7

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

हैश मैप

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

2. इसमें केवल अनन्य तत्व होते हैं।

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

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

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

LinkedHashMap

1. A LinkedHashMapमें कुंजी के आधार पर मान होते हैं।
2. इसमें केवल अनन्य तत्व होते हैं।
3. इसमें एक शून्य कुंजी और कई शून्य मान हो सकते हैं।

4. यह उसी प्रकार है जैसे HashMap प्रविष्टि के क्रम को बनाए रखता है । // नीचे वर्ग मंदी देखें

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

ट्री-मैप

1. A TreeMapमें कुंजी के आधार पर मान होते हैं। यह NavigableMap इंटरफ़ेस को लागू करता है और AbstractMap वर्ग का विस्तार करता है।
2. इसमें केवल अनन्य तत्व होते हैं।
3. इसमें शून्य कुंजी नहीं हो सकती है, लेकिन कई शून्य मान हो सकते हैं।

4. यह वैसा ही है जैसा कि आरोही क्रमHashMap बनाए रखता है (अपनी कुंजी के प्राकृतिक क्रम का उपयोग करके सॉर्ट किया गया है।)।

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

हैश टेबल

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

5. यह एक विरासत वर्ग है।

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

Ref: http://javarevisited.blogspot.in/2015/08/difference-between-HashMap-vs-TreeMap-vs-LinkedHashMap-Java.html

Comments

हैशपॉप का बिग-ओ नोटेशन ओ (1) नहीं होना चाहिए। यह सबसे अच्छा मामला है, और हैशटैब में ओ (एन) उनके सबसे खराब स्थिति के रूप में है। यह आपके लिंक द्वारा समर्थित है।

— हाकॉन लॉविटविट

यहाँ देखें - stackoverflow.com/questions/1055243/is-a-java-hashmap-really-o1/…

— roottraveller

@ HaakonLøtveit मैं यहां वास्तविक कोड के लिए जाने का सुझाव भी दूंगा

— grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/…

STILL का कहना है कि यह सबसे खराब स्थिति में O (n) है। यह एक गणितीय अवधारणा है, और आपको यह कहने की ज़रूरत नहीं है कि यह O (1) है, जब तक कि यह वास्तव में O (1) न हो। आप यहां कुछ बहुत अच्छे हैशिंग कार्यों को भी मान रहे हैं। मेरा मतलब है, हम कुछ का उपयोग कर सकते हैं जैसे कि वर्ग भयानक HashKey {@Override hashCode () {वापसी 4; / * उचित पासा फेंक * /}} द्वारा निर्धारित और अन्य मजेदार सामान के लिए एक कुंजी के रूप में उपयोग करें। O (1) की उच्च संभावना होना और O (1) का होना समान नहीं है। लोग यहां अपने होमवर्क के लिए मदद के लिए आते हैं। आइए उनके ग्रेड को बर्बाद न करें ..;)

— हाकोन लॉविट 16

और यह ध्यान देने योग्य होगा कि जावा 8 में आपके पास O (लॉग (n)) का सबसे खराब मामला है यदि आपके पास 8 से अधिक बाल्टी हैं, तो grepcode.com/file/repository.grepcode.com/java/root/bdk/openjdk देखें / ... इस बारे में जानकारी के लिए।

— हाकॉन लोट्टविट

Answer 8

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

देखिए कैसा रहा प्रदर्शन अलग-अलग ..

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

Answer 9

@Amit: SortedMapएक इंटरफ़ेस है जबकि TreeMapएक वर्ग है जो SortedMapइंटरफ़ेस को लागू करता है। इसका मतलब है कि अगर प्रोटोकॉल का पालन किया जाता है जो SortedMapइसके कार्यान्वयनकर्ताओं को करने के लिए कहता है। एक पेड़ जब तक खोज पेड़ के रूप में लागू नहीं किया जाता है, तब तक आप डेटा का आदेश नहीं दे सकते क्योंकि पेड़ किसी भी तरह का पेड़ हो सकता है। इसलिए ट्री मैप को क्रमबद्ध क्रम की तरह काम करने के लिए, यह SortedMap (उदाहरण के लिए, बाइनरी सर्च ट्री - BST, AVL और RB ट्री, यहां तक ​​कि टर्नेरी सर्च ट्री जैसे संतुलित बीएसटी - ज्यादातर ऑर्डर किए गए तरीके से पुनरावृत्त खोजों के लिए उपयोग किया जाता है) को लागू करता है।

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

नट-शेल में HashMap: O (1) में डेटा देता है, कोई ऑर्डर नहीं करता है

TreeMap : O (लॉग एन), बेस 2 में डेटा देता है। ऑर्डर की हुई चाबियों के साथ

LinkedHashMap: लिंक की गई सूची के साथ हैश टेबल है (इसे अनुक्रमित-स्किपलिस्ट के बारे में सोचें) डेटा को पेड़ में डालने के तरीके में संग्रहीत करने की क्षमता। LRU को लागू करने के लिए सबसे उपयुक्त (कम से कम हाल ही में प्रयुक्त)।

Answer 10

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

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

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

3. HashMap एक शून्य कुंजी और कई शून्य मानों को संग्रहीत कर सकता है ।reeMap में शून्य कुंजियाँ नहीं हो सकती हैं, लेकिन कई शून्य मान हो सकते हैं।

4. HashMap बेसिक ऑपरेशंस जैसे O और O (1) के लिए लगातार समय प्रदर्शन करते हैं। Oracle डॉक्स के अनुसार, TreeMap गेट और पुट विधि के लिए गारंटीकृत लॉग (n) समय लागत प्रदान करता है।

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

6. HashMap तुलना में बराबर () विधि का उपयोग करता है जबकि TreeMap क्रम बनाए रखने के लिए तुलना () विधि का उपयोग करता है।

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

Answer 11

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

जानकारी के लिए की जावाडोक पर देखने ट्री-मैप , HashMap , LinkedHashMap ।

Comments

वास्तव में हैशटेबल्स क्या हैं और यह एक मानचित्र से अलग क्या बनाता है।

— केविन

Answer 12

हैश मानचित्र प्रविष्टि क्रम को संरक्षित नहीं करता है।
उदाहरण। यदि आप के रूप में चाबियाँ डाल रहे हैं

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

Answer 13

• हैश मैप:

  • आदेश कायम नहीं है
  • LinkedHashMap की तुलना में तेज़
  • वस्तुओं के भंडार के लिए उपयोग किया जाता है

• LinkedHashMap:

  • LinkedHashMap प्रविष्टि क्रम बनाए रखा जाएगा
  • HashMap की तुलना में धीमी और TreeMap की तुलना में तेज़
  • यदि आप एक प्रविष्टि क्रम बनाए रखना चाहते हैं तो इसका उपयोग करें।

• ट्री-मैप:

  • ट्रीपैप एक ट्री-आधारित मैपिंग है
  • ट्रीपॉपर कुंजी के प्राकृतिक क्रम का पालन करेगा
  • HashMap और LinkedHashMap की तुलना में धीमी
  • जब आपको प्राकृतिक (डिफ़ॉल्ट) ऑर्डर बनाए रखने की आवश्यकता हो, तो TreeMap का उपयोग करें

Answer 14

सभी एक कुंजी-> मान मानचित्र और कुंजियों के माध्यम से पुनरावृत्ति करने का एक तरीका प्रदान करते हैं। इन वर्गों के बीच सबसे महत्वपूर्ण अंतर समय की गारंटी और कुंजियों का क्रम है।

1. HashMap 0 (1) देखने और सम्मिलन प्रदान करता है। यदि आप कुंजियों के माध्यम से पुनरावृत्ति करते हैं, हालांकि, चाबियों का क्रम अनिवार्य रूप से मनमाना है। इसे लिंक्ड लिस्ट की एक सरणी द्वारा कार्यान्वित किया जाता है।
2. TreeMap O (लॉग एन) लुकअप और प्रविष्टि प्रदान करता है। कुंजी का आदेश दिया जाता है, इसलिए यदि आपको क्रमबद्ध क्रम में कुंजियों के माध्यम से पुनरावृति करने की आवश्यकता है, तो आप कर सकते हैं। इसका मतलब यह है कि कुंजियों को तुलनात्मक इंटरफ़ेस को लागू करना चाहिए। ट्रीप रेड-ब्लैक ट्री द्वारा कार्यान्वित किया जाता है।
3. LinkedHashMap 0 (1) लुकअप और प्रविष्टि प्रदान करता है। कुंजी उनके सम्मिलन आदेश द्वारा आदेशित की जाती है। यह दोगुनी-लिंक्ड बाल्टियों द्वारा कार्यान्वित किया जाता है।

कल्पना करें कि आपने निम्नलिखित कार्य में एक रिक्त ट्रीपैप, हैशपॉप और लिंक्डहाशपप पास किया:

void insertAndPrint(AbstractMap<Integer, String> map) {
  int[] array= {1, -1, 0};
  for (int x : array) {
    map.put(x, Integer.toString(x));
  }
  for (int k: map.keySet()) {
   System.out.print(k + ", ");
  }
}

प्रत्येक के लिए आउटपुट नीचे दिए गए परिणामों की तरह दिखेगा।

हाशपैप के लिए, आउटपुट मेरे अपने परीक्षणों में था, {0, 1, -1}, लेकिन यह कोई भी ऑर्डर हो सकता है। आदेश देने की कोई गारंटी नहीं है।
ट्रेमेप, आउटपुट -1, 0, 1} लिंक्डलिस्ट था,
आउटपुट था, {1, -1, 0}

Answer 15

हालांकि यहाँ बहुत सारे बेहतरीन उत्तर हैं, मैं अपनी खुद की तालिका प्रस्तुत करना चाहूंगा Mapजिसमें जावा 11 के साथ विभिन्न कार्यान्वयन शामिल हैं।

हम टेबल ग्राफिक पर सूचीबद्ध इन अंतरों को देख सकते हैं:

• HashMapहै सामान्य प्रयोजन Map आमतौर पर इस्तेमाल आप कोई विशेष आवश्यकता है जब।
• LinkedHashMapHashMapइस व्यवहार को बढ़ाता है: एक आदेश बनाए रखता है, वह क्रम जिसमें प्रविष्टियाँ मूल रूप से जोड़ी गई थीं । कुंजी-मूल्य प्रविष्टि के लिए मान को बदलना क्रम में अपनी जगह नहीं बदलता है।
• TreeMapबहुत ही एक आदेश बनाए रखता है, लेकिन या तो (ए) "प्राकृतिक" आदेश का उपयोग करता है , जिसका अर्थ है compareToकि Comparableइंटरफ़ेस पर परिभाषित प्रमुख वस्तुओं पर विधि का मूल्य , या (बी) आपके द्वारा प्रदान किए गए कार्यान्वयन को लागू करता हैComparator ।
  • TreeMapSortedMapइंटरफ़ेस और उसके उत्तराधिकारी, इंटरफ़ेस दोनों को लागू करता NavigableMapहै।
• शून्य रों: TreeMapकरता नहीं कुंजी के रूप में एक शून्य की अनुमति देते हैं , जबकि HashMapऔर LinkedHashMapकरते हैं।
  • सभी तीन NULL को मान के रूप में अनुमति देते हैं।
• HashTableहै विरासत जावा 1 से, । ConcurrentHashMapवर्ग द्वारा पूरक । Javadoc का हवाला देते हुए: के ConcurrentHashMapरूप में एक ही कार्यात्मक विनिर्देश का पालन करता है Hashtable, और प्रत्येक विधि के अनुरूप विधियों के संस्करणों को शामिल करता है Hashtable।

Answer 16

HashMap
में एक नल कुंजी हो सकती है।

HashMap कोई आदेश नहीं रखता है।

ट्री-मैप

ट्रीपप में कोई नल कुंजी नहीं हो सकती है।

ट्रीपप आरोही क्रम बनाए रखता है।

LinkedHashMap

LinkedHashMap का उपयोग प्रविष्टि क्रम को बनाए रखने के लिए किया जा सकता है, जिस पर चाबियाँ मैप में डाली जाती हैं या इसका उपयोग एक्सेस ऑर्डर बनाए रखने के लिए भी किया जा सकता है, जिस पर कुंजियां एक्सेस की जाती हैं।

उदाहरण ::

1) हशपैप नक्शा = नया हशपप ();

    map.put(null, "Kamran");
    map.put(2, "Ali");
    map.put(5, "From");
    map.put(4, "Dir");`enter code here`
    map.put(3, "Lower");
    for (Map.Entry m : map.entrySet()) {
        System.out.println(m.getKey() + "  " + m.getValue());
    } 

2) ट्रीपैप मैप = नया ट्रीपैप ();

    map.put(1, "Kamran");
    map.put(2, "Ali");
    map.put(5, "From");
    map.put(4, "Dir");
    map.put(3, "Lower");
    for (Map.Entry m : map.entrySet()) {
        System.out.println(m.getKey() + "  " + m.getValue());
    }

3) लिंक्डहाशपैप नक्शा = नया लिंक्डहाशपैप ();

    map.put(1, "Kamran");
    map.put(2, "Ali");
    map.put(5, "From");
    map.put(4, "Dir");
    map.put(3, "Lower");
    for (Map.Entry m : map.entrySet()) {
        System.out.println(m.getKey() + "  " + m.getValue());
    }

Answer 17

तीनों में सबसे महत्वपूर्ण है कि वे प्रविष्टियों के क्रम को कैसे बचाते हैं।

HashMap- प्रविष्टियों के क्रम को नहीं बचाता है। जैसे।

public static void main(String[] args){
        HashMap<String,Integer> hashMap = new HashMap<>();
        hashMap.put("First",1);// First ---> 1 is put first in the map
        hashMap.put("Second",2);//Second ---> 2 is put second in the map
        hashMap.put("Third",3); // Third--->3 is put third in the map
        for(Map.Entry<String,Integer> entry : hashMap.entrySet())
        {
            System.out.println(entry.getKey()+"--->"+entry.getValue());
        }
    }

LinkedHashMap: यह उस क्रम को बचाता है जिसमें प्रविष्टियाँ की गई थीं। उदाहरण के लिए:

public static void main(String[] args){
        LinkedHashMap<String,Integer> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("First",1);// First ---> 1 is put first in the map
        linkedHashMap.put("Second",2);//Second ---> 2 is put second in the map
        linkedHashMap.put("Third",3); // Third--->3 is put third in the map
        for(Map.Entry<String,Integer> entry : linkedHashMap.entrySet())
        {
            System.out.println(entry.getKey()+"--->"+entry.getValue());
        }
    }

TreeMap: यह कुंजियों के आरोही क्रम में प्रविष्टियों को बचाता है। उदाहरण के लिए:

public static void main(String[] args) throws IOException {
        TreeMap<String,Integer> treeMap = new TreeMap<>();
        treeMap.put("A",1);// A---> 1 is put first in the map
        treeMap.put("C",2);//C---> 2 is put second in the map
        treeMap.put("B",3); //B--->3 is put third in the map
        for(Map.Entry<String,Integer> entry : treeMap.entrySet())
        {
            System.out.println(entry.getKey()+"--->"+entry.getValue());
        }
    }