दिलचस्प पोस्ट
सिग्नल के कारण कमांड विफल रहा: सेगमेंटेशन गलती: 11 प्ले-सर्विसेज़ स्थान को एंड्रॉइड पिरमिशन.WRITE_EXTERNAL_STORAGE और android.permission.READ_EXTERNAL_STORAGE अनुमति की आवश्यकता क्यों है? सभी अनुरोधों को index.php पर कैसे रीडायरेक्ट करें और अन्य जीईटी पैराम्हों को कैसे रखें? ग्रहण: एक ही बार में एकाधिक लॉन्च कॉन्फ़िगरेशन चलाना विशिष्ट तारीख को पास करके सप्ताह का दिन कैसे तय किया जाए? स्वयं को रद्द करने और कार्य को पुनरारंभ करने के लिए एक पैटर्न मेरा Magento एक्सटेंशन इंस्टॉल स्क्रिप्ट रन नहीं होगा जावास्क्रिप्ट में तारों को स्थानांतरित करें पायथन हेक्साडेसिमल Scala.concurrent.blocking के मामले का उपयोग करें क्या PHP में बिगइन्टेगर वर्ग है? क्रॉस-ऑरिजन अनुरोध पर अवरुद्ध Nginx 403 सभी फाइलों के लिए मना किया क्या एक सी कास्ट के माध्यम से एक स्ट्रेट के पहले फ़ील्ड को सख्त अलियासिंग का उल्लंघन करता है? किसी भी द्विआधारी पेड़ में दो नोड्स के सबसे कम सामान्य पूर्वज कैसे मिलेंगे?

जावा में हैशमैप और मानचित्र ऑब्जेक्ट्स के बीच अंतर क्या है?

निम्नलिखित मैप्स के निर्माण में अंतर क्या है (एक अन्य प्रश्न में, लोगों ने उत्तरदायी रूप से उनका उपयोग करते हुए उत्तर दिया और मैं सोच रहा हूं कि यदि वे अलग हैं):

HashMap<String, Object> map = new HashMap<String, Object>(); Map<String, Object> map = new HashMap<String, Object>(); 

Solutions Collecting From Web of "जावा में हैशमैप और मानचित्र ऑब्जेक्ट्स के बीच अंतर क्या है?"

वस्तुओं के बीच कोई अंतर नहीं है; आपके पास दोनों HashMap<String, Object> में एक HashMap<String, Object> है आपके पास ऑब्जेक्ट के लिए इंटरफ़ेस में अंतर है। पहले मामले में, इंटरफ़ेस HashMap<String, Object> , जबकि दूसरे में यह Map<String, Object> लेकिन अंतर्निहित ऑब्जेक्ट समान है

Map<String, Object> का उपयोग करने के लिए लाभ यह है कि आप अपने अनुबंध को बिना किसी संहिता को तोड़ते हुए एक अलग प्रकार का नक्शा बनाने के लिए अंतर्निहित ऑब्जेक्ट को बदल सकते हैं जो इसका इस्तेमाल करते हैं। यदि आप इसे HashMap<String, Object> रूप में घोषित करते हैं, तो आपको अपने अनुबंध को बदलना होगा यदि आप अंतर्निहित कार्यान्वयन को बदलना चाहते हैं


उदाहरण: मान लें कि मैं इस वर्ग को लिखता हूं:

 class Foo { private HashMap<String, Object> things; private HashMap<String, Object> moreThings; protected HashMap<String, Object> getThings() { return this.things; } protected HashMap<String, Object> getMoreThings() { return this.moreThings; } public Foo() { this.things = new HashMap<String, Object>(); this.moreThings = new HashMap<String, Object>(); } // ...more... } 

कक्षा में स्ट्रिंग-> ऑब्जेक्ट के कुछ आंतरिक मानचित्र होते हैं जो उप-क्लासेस के साथ साझा करता है (एक्सेसर तरीके के माध्यम से) मान लें कि मैं इसे HashMap साथ शुरू करने के लिए लिखता हूं क्योंकि मुझे लगता है कि क्लास लिखते समय उपयोग करने के लिए उपयुक्त संरचना है।

बाद में, मैरी ने कोड को उप-क्लासिंग किया। उसके पास कुछ और things और things और things करने की जरूरत है, इसलिए स्वाभाविक रूप से वह एक सामान्य तरीके से कहती है, और वह उसी पद्धति का उपयोग करती है जिसे मैं getThings / तरीके से अपने तरीके को परिभाषित करते समय मिलता है:

 class SpecialFoo extends Foo { private void doSomething(HashMap<String, Object> t) { // ... } public void whatever() { this.doSomething(this.getThings()); this.doSomething(this.getMoreThings()); } // ...more... } 

बाद में, मैं तय करता हूं कि वास्तव में, यह बेहतर होगा कि मैं Foo में TreeMap बजाय TreeMap उपयोग करें। मैं Foo अपडेट करता हूं, HashMap को HashMap लिए बदल रहा हूं। अब, SpecialFoo अब संकलन नहीं करता है, क्योंकि मैंने अनुबंध तोड़ा है: Foo कहता है कि यह TreeMaps प्रदान करता है, लेकिन अब यह TreeMaps प्रदान TreeMaps इसलिए हमें अब SpecialFoo को ठीक करना होगा (और इस तरह की बात को एक कोडबेस के माध्यम से तरंग सकते हैं)।

जब तक मुझे यह साझा करने का एक बहुत अच्छा कारण था कि मेरा कार्यान्वयन एक HashMap (और जो हो रहा है) का उपयोग कर रहा था, तो मुझे क्या करना चाहिए था, बातें getThings और अधिक से अधिक Map<String, Object> getMoreThings जैसे कि Map<String, Object> ; वास्तव में, कुछ और करने के लिए एक अच्छा कारण को छोड़कर, यहां तक ​​कि Foo भी मुझे संभवतः things और moreThings things घोषित करनी चाहिए, न कि moreThings / moreThings :

 class Foo { private Map<String, Object> things; // <== Changed private Map<String, Object> moreThings; // <== Changed protected Map<String, Object> getThings() { // <== Changed return this.things; } protected Map<String, Object> getMoreThings() { // <== Changed return this.moreThings; } public Foo() { this.things = new HashMap<String, Object>(); this.moreThings = new HashMap<String, Object>(); } // ...more... } 

ध्यान दें कि मैं अब Map<String, Object> हर जगह उपयोग कर रहा हूं, केवल जब मैं वास्तविक ऑब्जेक्ट्स बना सकता हूँ तब विशिष्ट है

अगर मैंने ऐसा किया होता, तो मैरी ने ऐसा किया होता:

 class SpecialFoo extends Foo { private void doSomething(Map<String, Object> t) { // <== Changed // ... } public void whatever() { this.doSomething(this.getThings()); this.doSomething(this.getMoreThings()); } } 

… और Foo बदलने से SpecialFoo स्टॉप कंपाइलिंग नहीं होता।

इंटरफेस (और आधार वर्ग) हमें आवश्यक रूप से जितना आवश्यक है उतनी ही प्रकट करें, जो उचित रूप में परिवर्तन करने के लिए कवर के तहत हमारे लचीलेपन को रखते हुए। सामान्य तौर पर, हम चाहते हैं कि हमारा संदर्भ यथासंभव बुनियादी हो। अगर हमें यह जानना जरूरी नहीं है कि यह एक HashMap , तो इसे Map

यह एक अंधा नियम नहीं है, लेकिन सामान्य तौर पर, सबसे सामान्य इंटरफ़ेस को कोडिंग को कोडिंग की अपेक्षा अधिक भंगुर होने जा रहा है। अगर मुझे यह याद आया, तो मैं एक Foo नहीं बनाया होता जो कि मरीय को SpecialFoo साथ विफल होने के लिए सेट करता था। अगर मैरी ने यह याद किया था कि, फिर भी मैंने Foo गड़बड़ कर दिया था, तो वह HashMap बजाय Map साथ अपना निजी तरीका घोषित कर लेगा और मेरे बदलते Foo के अनुबंध से उसके कोड को प्रभावित नहीं होता।

कभी-कभी आप ऐसा नहीं कर सकते, कभी-कभी आपको विशिष्ट होना पड़ता है लेकिन जब तक आपके पास कोई कारण नहीं है, तब तक कम से कम विशिष्ट इंटरफ़ेस की तरफ इशारा करें

मानचित्र एक इंटरफ़ेस है जो कि हैशमैप लागू करता है। अंतर यह है कि दूसरे कार्यान्वयन में आपके हाशम के संदर्भ में केवल मानचित्र इंटरफ़ेस में परिभाषित फ़ंक्शन के उपयोग की अनुमति होगी, जबकि पहले हाशम में किसी भी सार्वजनिक फ़ंक्शन का उपयोग करने की अनुमति देगा (जिसमें नक्शा इंटरफ़ेस भी शामिल है)।

यदि आप सूर्य का इंटरफ़ेस ट्यूटोरियल पढ़ते हैं तो यह संभवतः अधिक समझ जाएगा

मैं सिर्फ स्वीकार किए गए उत्तर पर एक टिप्पणी के रूप में ऐसा करने जा रहा था, लेकिन यह बहुत कायरता (मुझे लाइन ब्रेक न होने से नफरत है)

आह, तो अंतर यह है कि आम तौर पर, मानचित्र के कुछ तरीके इसके साथ जुड़े हैं। लेकिन इसमें अलग-अलग तरीके हैं या एक मानचित्र बनाते हैं, जैसे कि हैशमैप, और ये अलग-अलग तरीके अद्वितीय तरीके प्रदान करते हैं जो सभी नक्शे नहीं हैं।

बिल्कुल – और आप हमेशा सबसे अधिक सामान्य इंटरफ़ेस का उपयोग करना चाहते हैं, जो संभवतः आप कर सकते हैं। ArrayList vs LinkedList पर विचार करें आप उनका उपयोग कैसे करते हैं, इसके विशाल अंतर, लेकिन यदि आप "सूची" का उपयोग करते हैं, तो आप उनके बीच आसानी से स्विच कर सकते हैं।

वास्तव में, आप अधिक गतिशील वक्तव्य के साथ प्रारंभकर्ता के दाईं ओर की जगह ले सकते हैं। इस जैसे किसी और के बारे में क्या राय है:

 List collection; if(keepSorted) collection=new LinkedList(); else collection=new ArrayList(); 

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

यह एक बहुत बड़ा खंड है क्योंकि संग्रह का सबसे अच्छा उदाहरण नहीं है, लेकिन ओओ डिज़ाइन में सबसे महत्वपूर्ण अवधारणाओं में से एक इंटरफ़ेस मुखौटा का इस्तेमाल सटीक एक ही कोड के साथ विभिन्न वस्तुओं का उपयोग करने के लिए किया जा रहा है।

टिप्पणी का जवाब संपादित करें:

नीचे आपकी मानचित्र टिप्पणी के लिए, "मानचित्र" इंटरफ़ेस का उपयोग करके आप केवल उन्हीं विधियों तक ही सीमित कर देते हैं जब तक कि आप मानचित्र से वापस हाशमप (जो पूरी तरह से उद्देश्य को हरा देता है) का संग्रह करते हैं।

अक्सर आप क्या करेंगे, एक वस्तु बनाते हैं और इसे किसी विशिष्ट प्रकार (हैशमप) का उपयोग करके इसे "बनाते हैं" या "प्रारंभिक" पद्धति में भरते हैं, लेकिन यह विधि एक "मानचित्र" को वापस कर देगी जो कि किसी भी हैशमैप के रूप में हेरफेर

यदि आपको कभी भी रास्ता डालना पड़ता है, तो आप शायद गलत इंटरफ़ेस का उपयोग कर रहे हैं या आपका कोड अच्छी तरह से संरचित नहीं है ध्यान दें कि आपके कोड का एक हिस्सा इसे "हैशमप" के रूप में मानते हैं जबकि दूसरे इसे "मानचित्र" के रूप में मानते हैं, लेकिन यह "नीचे" होना चाहिए ताकि आप कभी भी कास्टिंग न करें।

इंटरफेस द्वारा दर्शाए गए भूमिकाओं के अर्द्ध-साफ पहलू को भी नोटिस करें। एक लिंक्डलिस्ट एक अच्छा स्टैक या कतार बनाता है, एक ArrayList एक अच्छा स्टैक बनाता है, लेकिन एक भयावह कतार (फिर से, एक निकासी पूरी सूची में बदलाव का कारण होगा) इसलिए लिंक्डलिस्ट क्वू इंटरफ़ेस लागू करता है, ArrayList नहीं करता है।

यहां छवि विवरण दर्ज करें

निम्नलिखित कार्यान्वयन वाले मानचित्र,

  1. हैशमैप Map m = new HashMap();

  2. LinkedHashMap Map m = new LinkedHashMap();

  3. ट्री मानचित्र Map m = new TreeMap();

  4. WeakHashMap Map m = new WeakHashMap();

मान लीजिए आपने एक विधि बनाई है (यह सिर्फ स्पुडो कोड है)।

 public void HashMap getMap(){ return map; } 

मान लीजिए कि आप प्रोजेक्ट की आवश्यकता हर बार बदल रहे हैं,

  1. विधि मानचित्र सामग्री को वापस करनी चाहिए – HashMap वापस करने की आवश्यकता है
  2. मेथड को मानचित्रण की प्रविष्टि के क्रम में वापस करना चाहिए – लिंक प्रकार LinkedHashMap से LinkedHashMap को बदलने की आवश्यकता है।
  3. विधि मानचित्र कुंजी की क्रमबद्ध क्रम में वापस LinkedHashMap चाहिए – लौटने के प्रकार LinkedHashMap को TreeMap को बदलने की आवश्यकता है।

यदि आपका तरीका Map इंटरफ़ेस के बदले विशिष्ट वर्गों को लौटता है तो आपको हर बार वापसी के प्रकार के getMap() विधि को बदलना होगा।

लेकिन, यदि आप जावा की बहुरूपता सुविधा का उपयोग करते हैं, तो विशिष्ट श्रेणी के उपयोग किए गए इंटरफ़ेस Map पर लौटने के बजाय, यह कोड पुन: प्रयोज्यता और कम प्रभाव पड़ता है यदि कोई भी आवश्यकता परिवर्तन होता है।

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

आपके दूसरे उदाहरण में "नक्शा" संदर्भ एक प्रकार का Map , जो HashMap (और अन्य प्रकार के Map ) द्वारा कार्यान्वित एक इंटरफ़ेस है। यह इंटरफ़ेस एक ऐसा अनुबंध है जो ऑब्जेक्ट नक्शे कुंजियों को मानता है और विभिन्न कार्यों का समर्थन करता है (उदाहरण के put , get )। यह Map के कार्यान्वयन के बारे में कुछ नहीं कहता है (इस मामले में एक HashMap )।

दूसरा दृष्टिकोण आम तौर पर पसंद किया जाता है क्योंकि आप आमतौर पर नक्शा का उपयोग करने के तरीकों या एपीआई परिभाषा के माध्यम से विशिष्ट नक्शा कार्यान्वयन को बेनकाब नहीं करना चाहते हैं।

नक्शा स्थिर प्रकार का नक्शा है, जबकि हैशमैप मानचित्र की गतिशील प्रकार है। इसका मतलब यह है कि कंपाइलर आपके मानचित्र ऑब्जेक्ट को एक प्रकार के मानचित्र के रूप में व्यवहार करेगा, भले ही रनटाइम पर, यह इसके किसी भी उपप्रकार को इंगित कर सकता है

कार्यान्वयन के बजाय इंटरफेस के साथ प्रोग्रामिंग के इस अभ्यास में शेष लचीलापन का अतिरिक्त लाभ होता है: उदाहरण के लिए, आप रनटाइम पर गतिशील प्रकार के मानचित्र को बदल सकते हैं, जब तक कि यह मानचित्र का उपप्रकार (जैसे लिंकेडहाशमैप) है, और मैप का व्यवहार बदलता है मक्खी।

अंगूठे का एक अच्छा नियम एपीआई स्तर पर यथासंभव अमूर्त बने रहना है: उदाहरण के लिए यदि आपको एक प्रोग्रामिंग की ज़रूरत है तो मानचित्र पर काम करना चाहिए, फिर इसे कड़ाई के बजाय मानचित्र के रूप में पैरामीटर घोषित करने के लिए पर्याप्त है (क्योंकि कम सार) हैशमार्क प्रकार । इस प्रकार, आपके एपीआई के उपभोक्ता आपके विधि से किस तरह के मानचित्र कार्यान्वयन करना चाहते हैं, इस बारे में लचीला हो सकता है

आप समान मानचित्र बनाते हैं।

लेकिन जब आप इसका प्रयोग करेंगे तब आप अंतर भर सकते हैं पहले मामले के साथ आप विशेष हैशमैप विधियों का उपयोग करने में सक्षम होंगे (लेकिन मुझे किसी को वास्तव में उपयोगी नहीं याद है), और आप इसे हाशमैप पैरामीटर के रूप में पास कर पाएंगे:

 public void foo (HashMap<String, Object) { ... } ... HashMap<String, Object> m1 = ...; Map<String, Object> m2 = ...; foo (m1); foo ((HashMap<String, Object>)m2); 

मानचित्र इंटरफ़ेस है और हॅशमैप एक ऐसा वर्ग है जो मानचित्र इंटरफ़ेस लागू करता है

मानचित्र इंटरफ़ेस है और हाशमैप एक ऐसा क्लास होता है जो इसका पालन करता है।

इसलिए इस कार्यान्वयन में आप एक ही ऑब्जेक्ट बनाते हैं

हैशमैप मानचित्रण का एक कार्यान्वयन है, इसलिए यह काफी समान है, लेकिन "क्लोन ()" विधि के रूप में मैं संदर्भ गाइड में देखता हूं)

 HashMap<String, Object> map1 = new HashMap<String, Object>(); Map<String, Object> map2 = new HashMap<String, Object>(); 

सबसे पहला Map एक इंटरफ़ेस है, TreeHashMap , LinkedHashMap , LinkedHashMap इत्यादि जैसे विभिन्न कार्यान्वयन हैं। इंटरफ़ेस कार्यान्वयन वर्ग के लिए एक सुपर क्लास की तरह काम करता है। तो ओओपी के नियम के अनुसार Map लागू करने वाले किसी भी ठोस वर्ग का एक Map भी है। इसका मतलब है कि हम किसी भी प्रकार के बिना किसी भी प्रकार के Map प्रकार को किसी भी HashMap प्रकार के चर को निर्दिष्ट / रख सकते हैं।

इस मामले में हम map1 को बिना किसी कास्टिंग या किसी डेटा के खोने के स्थान पर निर्दिष्ट कर सकते हैं –

 map2 = map1 

"अधिक सामान्य, बेहतर" पर बल देते हुए शीर्ष मतदान वाले उत्तर और कई लोगों के ऊपर जोड़ना, मैं थोड़ा और अधिक खोदना चाहता हूं

Map संरचना अनुबंध है, जबकि HashMap एक वास्तविक कार्यान्वयन है जो कि विभिन्न वास्तविक समस्याओं से निपटने के लिए अपनी पद्धतियां प्रदान करता है: सूचकांक की गणना कैसे करें, क्षमता कितनी है और इसे कैसे बढ़ाएं, कैसे डालें, सूचकांक को कैसे अनूठा रखना है आदि

आइए स्रोत कोड में देखें:

Map हमारे पास की की containsKey(Object key) :

 boolean containsKey(Object key); 

JavaDoc:

बूलियन जावा। ऊतक। मैप.containsValue (वस्तु मान)

अगर यह मैप निर्दिष्ट मूल्य के लिए एक या एक से अधिक कुंजी मैप करता है, तो सत्य वापस लौटाता है। अधिक औपचारिक रूप से, यदि सही है तो और अगर केवल इस नक्शे में कम से कम एक मानचित्रण को मान v जैसे कि (value==null ? v==null : value.equals(v)) । मानचित्र ऑपरेशन के अधिकांश कार्यान्वयन के लिए इस ऑपरेशन को संभवतः नक्शे के आकार में समय रैखिक की आवश्यकता होगी।

पैरामीटर: मूल्य

मूल्य जिसका इस नक्शे में उपस्थित होना चाहिए

यह दिखाता है: सच

यदि यह नक्शा निर्दिष्ट करने के लिए एक या एक से अधिक कुंजी है

valueThrows:

ClassCastException – यदि मान इस मैप के लिए अनुचित प्रकार का है (वैकल्पिक)

NullPointerException – यदि निर्दिष्ट मान शून्य है और यह मानचित्र शून्य मानों (वैकल्पिक) की अनुमति नहीं देता है

इसे कार्यान्वित करने के लिए इसके कार्यान्वयन की आवश्यकता है, लेकिन इसकी स्वतंत्रता पर "कैसे" है, केवल यह सुनिश्चित करने के लिए कि वह सही रिटर्न करे

HashMap :

 public boolean containsKey(Object key) { return getNode(hash(key), key) != null; } 

यह पता चला है कि HashMap परीक्षण करने के लिए HashMap का उपयोग करता है यदि इस मैप में कुंजी है। तो यह हैश एल्गोरिथ्म का लाभ है