जावा में मानचित्र इंटरफ़ेस

जावा मैप इंटरफेस क्या है

जावा मानचित्र इंटरफ़ेस जावा संग्रह ढांचे का एक हिस्सा है, लेकिन यह संग्रह इंटरफ़ेस का उपप्रकार नहीं है। तो यह सूची, या अन्य संग्रह वस्तुओं की तुलना में अलग तरीके से व्यवहार करता है। मानचित्र <कुंजी, मान> का प्रत्येक तत्व एक कुंजी-मूल्य जोड़ी का प्रतिनिधित्व करता है। कुंजी और मान दोनों ही कुछ वस्तुएँ हैं। किसी विशेष मानचित्र में सभी कुंजियाँ अद्वितीय हैं, जबकि मान नहीं हैं, इसलिए उन्हें डुप्लिकेट किया जा सकता है। आप जावा में मानचित्र के बारे में सोच सकते हैं जैसे कि एक प्रकार का शब्दकोश या ऑनलाइन-शॉप कैटलॉग, जहां आप अपनी अनूठी अनुक्रमणिका का उपयोग करके कोई आइटम पा सकते हैं। कुंजी मानचित्र में मान का एक अद्वितीय पहचानकर्ता है। उदाहरण के लिए मानचित्र में <स्ट्रिंग, आइटम> स्ट्रिंग ऑनलाइन दुकान से कुछ आइटम की एक आईडी है। दस्तावेज़ीकरण के अनुसार मानचित्र में अगला सबइंटरफेस है:

बंधन ;
• समवर्ती मानचित्र <के, वी> ;
• समवर्ती नेविगेशन योग्य मानचित्र <के, वी> ;
• तार्किक संदेश प्रसंग ;
• संदेश कॉन्टेक्स्ट ;
• नेविगेट करने योग्य मानचित्र <के, वी> ;
• SOAPMessageContext ;
• क्रमबद्ध मानचित्र <के, वी> ।

और कक्षाएं लागू करता है:

• सार नक्शा
• गुण
• प्रामाणिकप्रदाता
• समवर्ती हैशमैप
• समवर्तीSkipListMap
• EnumMap
• हैश मैप
• हैश तालिका
• आइडेंटिटी हैश मैप
• लिंक्ड हैशमैप
• प्रिंटरस्टेटकारण
• गुण
• प्रदाता
• रेंडरिंगहिंट्स
• सिंपलबाइंडिंग्स
• सारणीबद्ध डेटा समर्थन
• ट्री-मैप
• UIDefaults
• कमजोर हैश मैप

• जावा एब्सट्रैक्ट मैप एक अमूर्त वर्ग है जो अधिकांश मैप इंटरफेस को लागू करता है।
• जावा हैश मैप हैश तालिका का उपयोग करके कुंजी-मूल्य जोड़े को संग्रहीत करने के लिए एक डेटा संरचना है।
• Java TreeMap एक ट्री का उपयोग करने के लिए एक डेटा संरचना है, अर्थात सॉर्ट की गई कुंजियों के साथ प्रदर्शित होती है।
• WeakHashMap कमजोर कुंजियों के साथ हैश तालिका का उपयोग करने के लिए, उन मूल्यों के साथ प्रदर्शित करता है जिन्हें कचरा संग्राहक द्वारा हटाया जा सकता है यदि वे अब उपयोग नहीं किए जाते हैं।
• LinkedHashMap तत्वों को जोड़ने के क्रम के साथ एक नक्शा है, सम्मिलन क्रम में पुनरावृत्ति की अनुमति देता है।
• EnumMap एनम कुंजियों के साथ उपयोग के लिए एब्सट्रैक्ट मैप क्लास का विस्तार करता है ।
IdentityHashMap दस्तावेज़ों की तुलना करते समय रेफ़रेंशियल तुल्यता जाँच का उपयोग करता है, बराबर () विधि के बजाय == ऑपरेशन का उपयोग करके कुंजियों के साथ मैपिंग करता है

यहां हम मैप इंटरफेस के सबसे लोकप्रिय कार्यान्वयन में रुचि रखते हैं: हैश मैप, ट्री मैप और लिंक्ड हैश मैप। वैसे, नक्शा तत्वों का क्रम विशिष्ट कार्यान्वयन पर निर्भर करता है। कहें, TreeMap और LinkedHashMap में तत्वों का अनुमानित क्रम है, जबकि हैश मैप नहीं है।

मानचित्र के तरीके

किसी भी मानचित्र का मुख्य संचालन तत्वों का सम्मिलन, निष्कासन और खोज है।

• सार्वजनिक ऑब्जेक्ट पुट (ऑब्जेक्ट कुंजी, ऑब्जेक्ट वैल्यू) मानचित्र में एक तत्व सम्मिलित करता है।
• सार्वजनिक शून्य putAll (मानचित्र मानचित्र) निर्दिष्ट मानचित्र को मानचित्र के अंदर सम्मिलित करता है।
• पब्लिक ऑब्जेक्ट रिमूव (ऑब्जेक्ट कुंजी) निर्दिष्ट कुंजी के अनुसार एक प्रविष्टि को हटा देता है।
• सार्वजनिक ऑब्जेक्ट प्राप्त करें (ऑब्जेक्ट कुंजी) निर्दिष्ट कुंजी के लिए मान लौटाता है।
• सार्वजनिक बूलियन सम्‍मिलित है (ऑब्जेक्ट कुंजी) इस मानचित्र से निर्दिष्ट कुंजी की खोज करता है
• सार्वजनिक सेट कीसेट () एक सेट दृश्य देता है जिसमें सभी कुंजियाँ होती हैं
• सार्वजनिक सेट प्रविष्टिसेट () सभी कुंजियों और मूल्यों के साथ एक सेट दृश्य लौटाता है।

हैशमैप क्या है

हैशमैप क्या है? यह Map<Key,Value> इंटरफ़ेस का सबसे लोकप्रिय कार्यान्वयन है। यह डेटा संरचना हैशिंग सिद्धांत पर आधारित है।

हैश मैप काम का मुख्य सिद्धांत: हैशिंग

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

1. एक विशेष इनपुट (ऑब्जेक्ट) में एक विशेष हैश कोड होता है।
2. यदि दो वस्तुएँ समान हैं, तो उनके हैश कोड भी समान हैं। उलटा सच नहीं है।
3. यदि हैश कोड अलग हैं, तो वस्तु निश्चित रूप से समान नहीं है।
4. कभी-कभी विभिन्न वस्तुओं में एक ही हैश कोड हो सकता है। यह एक बहुत ही असंभावित घटना है, जिसे "टकराव" नाम दिया गया है और एक अच्छी गुणवत्ता वाले हैश फ़ंक्शन को टकराव की संभावना को कम करना चाहिए।

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

हैश मैप: यह कैसे काम करता है

तो क्लास हैश मैप <के, वी> क्योंकि प्रत्येक मानचित्र कार्यान्वयन में कुंजी और मान होते हैं। यह हैशिंग सिद्धांतों का उपयोग करके कुंजियों को संग्रहीत करता है। हैश मैप के अंदर कुंजी-मूल्य जोड़े "बकेट" में संग्रहीत होते हैं, ये बाल्टी एक साथ "टेबल" बनाते हैं, लिंक्ड सूचियों की एक आंतरिक सरणी और इसका प्रारंभिक आकार 16 है. जावा में हैश मैप एक बाल्टी निर्धारित करने के लिए कुंजी के हैशकोड का उपयोग करता है जहां कुंजी/मान जोड़ी को मैप करना चाहिए: हैश मैप की मुश्किल विशेषता यह है कि तालिका का प्रत्येक सेल (बाल्टी) [] न केवल एक जोड़ी बल्कि कई रखता है। वे एक स्पष्ट वस्तु (जैसे लिंक्डलिस्ट) के रूप में संग्रहीत नहीं हैं, लेकिन एक अंतर्निहित श्रृंखला के रूप में। श्रृंखला इस तथ्य के कारण बनाई गई है कि प्रत्येक जोड़ी अगली जोड़ी के लिए एक लिंक संग्रहीत करती है। यही है, सभी हैश मैप जोड़े 16 श्रृंखलाओं में फैले हुए हैं। जब आप तालिका में एक नई जोड़ी रखते हैं, तो कुंजी का हैश माना जाता है। यह हैश कुंजी ऑब्जेक्ट में निर्मित हैशकोड फ़ंक्शन नहीं है। इसे 0-15 की सीमा में माना जाता है। जोड़ी को हैश इंडेक्स के साथ बाल्टी में संग्रहीत जोड़े की श्रृंखला में जोड़ा जाता है। यह दृष्टिकोण हमें खोज त्वरण देता है। कुंजी द्वारा एक जोड़ी की खोज करते समय, संपूर्ण तालिका के माध्यम से जाने की कोई आवश्यकता नहीं है। कुंजी के हैश पर विचार किया जाता है और हैश इंडेक्स वाले सेल में संग्रहीत श्रृंखला की जांच की जाती है। यदि हैश मैप में बहुत अधिक जोड़े हैं, तो श्रृंखला बहुत लंबी हो जाती है। फिर सरणी का आकार बढ़ता है, सभी संग्रहीत वस्तुओं के हैश की पुनर्गणना की जाती है, और वे नई श्रृंखलाओं के साथ बिखर जाते हैं।

हैश मैप घोषणा

यदि आप कक्षा हैश मैप कोड पर जाते हैं तो आपको अगली घोषणा मिल जाएगी:

public class HashMap extends AbstractMap implements Map, Cloneable, Serializable

जहाँ K इस मानचित्र द्वारा अनुरक्षित कुंजियों का प्रकार है और V - मैप किए गए मानों का प्रकार है। यह आपके कोड में पूर्णांक कुंजी और स्ट्रिंग मान के साथ हैश मैप घोषणा का एक उदाहरण है:

HashMap<Integer, String> myHashMap = new HashMap<Integer, String>();

हैश मैप तरीके

यहाँ हैश मैप विधियों की सूची दी गई है।

• ऑब्जेक्ट प्राप्त करें (ऑब्जेक्ट कुंजी) निर्दिष्ट कुंजी के लिए मान लौटाता है;
• ऑब्जेक्ट पुट (कुंजी k, मान v) मानचित्र में कुंजी मान मैपिंग सम्मिलित करता है;
• ऑब्जेक्ट रिमूव (ऑब्जेक्ट कुंजी) मौजूद होने पर इस मैप से निर्दिष्ट कुंजी के लिए मैपिंग को हटा देता है;
• शून्य स्पष्ट () हैश मैप से सभी कुंजी-मूल्य जोड़े हटा देता है;
• ऑब्जेक्ट क्लोन () कुंजियों और मूल्यों को क्लोन किए बिना इस हैश मैप उदाहरण की उथली प्रति देता है;
• बूलियन सम्‍मिलित कुंजी (ऑब्‍जेक्‍ट कुंजी) मैप में निर्दिष्ट कुंजी मिलने पर सही रिटर्न देता है, यदि नहीं है तो गलत;
• बूलियन सम्‍मिलित वैल्‍यू (ऑब्‍जेक्‍ट वैल्‍यू) मैप में निर्दिष्ट कुंजी मिलने पर सही रिटर्न देता है, यदि नहीं है तो गलत;
• बूलियन isEmpty() सही है अगर नक्शा खाली है, गलत है अगर नहीं है;
• सेट कीसेट () मानचित्र से प्राप्त की गई कुंजियों का सेट लौटाता है;
• int size() की-वैल्यू मैपिंग की मात्रा लौटाता है;
• संग्रह मान () मानचित्र के मूल्यों का संग्रह लौटाता है;
• ऑब्जेक्ट रिमूव (ऑब्जेक्ट की) निर्दिष्ट कुंजी के लिए की-वैल्यू पेयर को हटा देता है;
• शून्य putAll (मानचित्र एम) मानचित्र के सभी तत्वों को दूसरे मानचित्र पर कॉपी करता है।

जावा हैश मैप उदाहरण

यह कैसे काम करता है यह प्रदर्शित करने के लिए जावा हैश मैप उदाहरण के साथ एक प्रोग्राम बनाएं:

import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;
import java.util.Set;

public class HashMap {

   public static void main(String[] args) {

       {

           // HashMap declaration
           HashMap<Integer, String> myHashMap = new HashMap<Integer, String>();

           //Adding elements into HashMap
           myHashMap.put(7, "Johnny");
           myHashMap.put(8, "Ivy");
           myHashMap.put(1, "Rick");
           myHashMap.put(4, "Stan");
           myHashMap.put(3, "Kyle");

           //print out the map content using Iterator
           Set set = myHashMap.entrySet();
           Iterator iterator = set.iterator();
           while (iterator.hasNext()) {
               Map.Entry mapEntry = (Map.Entry) iterator.next();
               System.out.print("key: " + mapEntry.getKey() + " value: ");
               System.out.println(mapEntry.getValue());
           }
           System.out.println("get an element from myHashMap via key and print the value out:");
           System.out.println(myHashMap.get(8));
           //print out hashMap on standard way:
           System.out.println(myHashMap);

           // Get values based on key
           String var = myHashMap.get(2);
           //here we'll get null, we don't have such a key
           System.out.println("Value with key 2: " + var);
           var = myHashMap.get(7);
           System.out.println("Value with key 7: " + var);

           // Remove values based on key
           myHashMap.remove(4);
           System.out.println("myHashMap after removing element:");
           System.out.println(myHashMap);
           myHashMap.clear();
           System.out.println("myHashMap after total clearing:");
           System.out.println(myHashMap);
       }

   }
}

कार्यक्रम चलाने का परिणाम:

key: 1 value: Rick
key: 3 value: Kyle
key: 4 value: Stan
key: 7 value: Johnny
key: 8 value: Ivy
get an element from myHashMap via key and print the value out:
Ivy
{1=Rick, 3=Kyle, 4=Stan, 7=Johnny, 8=Ivy}
Value with key 2: null
Value with key 7: Johnny
myHashMap after removing element:
{1=Rick, 3=Kyle, 7=Johnny, 8=Ivy}
myHashMap after total clearing:
{}

ट्री-मैप

Java में TreeMap भी Map<Key,Value> इंटरफेस को लागू करता है, लेकिन यह रेड-ब्लैक ट्री डेटा स्ट्रक्चर पर आधारित है। एक पेड़ में "नोड्स" और लाइनें होती हैं जो नोड्स - शाखाओं को जोड़ती हैं। "रूट" नोड पेड़ के शीर्ष पर है। रूट से शाखाएं और नोड्स हो सकते हैं। यह एक पदानुक्रमित संरचना है, आप सोच सकते हैं इन नोड्स को जड़ के "बच्चों" के रूप में। चाइल्ड नोड के अपने बच्चे हो सकते हैं - निचले नोड्स। बच्चों के बिना नोड्स को "एंड-नोड्स" या "पत्तियां" कहा जाता है। एक बाइनरी ट्री एक पेड़ है, जहां हर नोड में शून्य होता है, एक , या दो बच्चे। बाइनरी सर्च ट्री एक संरचना है, जहां हर आंतरिक नोड एक कुंजी, और कभी-कभी एक संबद्ध मान संग्रहीत करता है, और इसके दो विशिष्ट उप-पेड़ ("बाएं" और "दाएं") होते हैं। एक स्व-संतुलन बाइनरी सर्च ट्री एक नोड-आधारित बाइनरी सर्च ट्री है जो मनमाना आइटम सम्मिलन और विलोपन के चेहरे में स्वचालित रूप से अपनी ऊंचाई (रूट के नीचे स्तरों की अधिकतम संख्या) को छोटा रखता है। लाल-काले पेड़ गुणों के साथ एक संतुलित बाइनरी पेड़ है:

• हर नोड या तो लाल या काला है
• जड़ हमेशा काली होती है
• प्रत्येक पत्ता एक NIL (खाली, अशक्त) नोड है और यह काला है
• यदि कोई नोड लाल है, तो उसके बच्चे निश्चित रूप से काले हैं।
• एक नोड से एक वंशज पत्ती तक हर सरल पथ में समान संख्या में काले नोड होते हैं।

एक ट्रीमैप सुविधाएँ

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

ट्रीमैप तरीके

• ऑब्जेक्ट प्राप्त करें (ऑब्जेक्ट कुंजी) संबंधित कुंजी का मान लौटाता है;
• ऑब्जेक्ट पुट (ऑब्जेक्ट कुंजी, ऑब्जेक्ट वैल्यू) मानचित्र में मैपिंग सम्मिलित करता है;
• ऑब्जेक्ट रिमूव (ऑब्जेक्ट कुंजी) इस कुंजी के लिए मैपिंग को हटा देता है यदि ट्रीमैप में यह शामिल है;
• बूलियन सम्‍मिलित कुंजी (ऑब्जेक्ट कुंजी) सही है यदि इस मानचित्र में निर्दिष्ट कुंजी के लिए मैपिंग शामिल है;
• बूलियन सम्‍मिलित वैल्‍यू (ऑब्‍जेक्‍ट वैल्‍यू) सही रिटर्न देता है यदि ट्रीमैप निर्दिष्ट मान के लिए एक या अधिक कुंजियों को मैप करता है;
• ऑब्जेक्ट फर्स्टके () वर्तमान में सॉर्ट किए गए मानचित्र में पहली कुंजी लौटाता है;
• ऑब्जेक्ट lastKey() वर्तमान में सॉर्ट किए गए मानचित्र में अंतिम कुंजी लौटाता है;
• शून्य putAll(नक्शा नक्शा) निर्दिष्ट मानचित्र से मानचित्र पर सभी मैपिंग की प्रतिलिपि बनाता है;
• एंट्रीसेट सेट करें() मैपिंग का एक सेट व्यू लौटाता है
• int size() की-वैल्यू मैपिंग की मात्रा लौटाता है
• संग्रह मान() मानों का संग्रह दृश्य लौटाता है
• ऑब्जेक्ट क्लोन () ट्री मैप की उथली प्रति लौटाता है
• शून्य स्पष्ट () ट्री मैप से सभी मैपिंग को हटा देता है
• SortedMap हेडमैप (ऑब्जेक्ट key_value) पैरामीटर key_value से कम मानचित्र के हिस्से का एक दृश्य देता है
• सेट कीसेट () ट्रीमैप में निहित कुंजियों का सेट दृश्य लौटाता है
• सॉर्टेडमैप सबमैप (K fromKey, K toKey) इस मैप के हिस्से का एक दृश्य लौटाता है, जिसकी कुंजियाँ fromKey, समावेशी, toKey, अनन्य तक होती हैं
• ऑब्जेक्ट फर्स्टके () ट्रीमैप से पहली कुंजी लौटाता है।

ट्रीमैप उदाहरण

import java.util.TreeMap;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;

public class TreeMapExample {

   public static void main(String args[]) {

       //TreeMap declaration
       TreeMap<Integer, String> myTreeMap = new TreeMap<Integer, String>();

       //put elements to TreeMap
       myTreeMap.put(1, "Stuart");
       myTreeMap.put(23, "Michael");
       myTreeMap.put(7, "Johnny");
       myTreeMap.put(5, "Ivy");
       myTreeMap.put(2, "Alex");

       //Display and print out myTreeMap using Iterator
       Set set = myTreeMap.entrySet();
       Iterator iterator = set.iterator();
       while (iterator.hasNext()) {
           Map.Entry myEntry = (Map.Entry) iterator.next();
           System.out.print("key: " + myEntry.getKey() + " value: ");
           System.out.println(myEntry.getValue());
       }
       //TreeMap printed in classical way
       System.out.println(myTreeMap);
       //removing an element with the key =2
       myTreeMap.remove(2);
       //myTreeMap after removing:
       System.out.println(myTreeMap);
   }
}

कार्यक्रम चलाने का परिणाम:

key: 1 value: Stuart
key: 2 value: Alex
key: 5 value: Ivy
key: 7 value: Johnny
key: 23 value: Michael
{1=Stuart, 2=Alex, 5=Ivy, 7=Johnny, 23=Michael}
{1=Stuart, 5=Ivy, 7=Johnny, 23=Michael}

लिंक्ड हैशमैप

LinkedHashMap एक डेटा संरचना है जो लिंक की गई सूचियों और हैश मैप्स को जोड़ती है। वास्तव में, LinkedHashMap, HashMap वर्ग का विस्तार करता है और मानचित्र इंटरफ़ेस को लागू करता है, लेकिन यह लिंक्ड सूचियों के बारे में क्या है? LinkedHashMap की घोषणा:

Map <Integer, String> linkedHashMap = new LinkedHashMap <Integer, String>();

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

• हेडर दोगुनी लिंक की गई सूची का प्रमुख है। आरंभीकरण के दौरान, यह खुद को इंगित करता है
• AccessOrder इंगित करता है कि इटरेटर का उपयोग करके तत्वों तक कैसे पहुँच प्राप्त करें। यदि सही है, अंतिम पहुँच के क्रम में। यदि गलत है, तो ऐक्सेस उस क्रम में होगा जिस क्रम में तत्व डाले गए थे।

यह लिंक की गई सूची पुनरावृति क्रम को परिभाषित करती है। आमतौर पर, यह मानचित्र में कुंजियों के सम्मिलन का क्रम होता है।

लिंक्ड हैश मैप तरीके

• ऑब्जेक्ट प्राप्त करें (ऑब्जेक्ट कुंजी) उस मान को लौटाता है जिसके लिए निर्दिष्ट कुंजी मैप की गई है, या शून्य अगर इस मानचित्र में कुंजी के लिए कोई मैपिंग नहीं है
• शून्य स्पष्ट () मानचित्र से सभी मैपिंग को हटा देता है।
• बूलियन सम्‍मिलित कुंजी (ऑब्जेक्ट कुंजी) सही लौटाता है यदि निर्दिष्ट तत्व को एक या अधिक कुंजियों द्वारा मैप किया जाता है
• बूलियन रिमूवएल्डेस्टएंट्री (मैप.एंट्री ज्येष्ठ) सच लौटाता है यदि मानचित्र मानचित्र से अपनी सबसे बड़ी प्रविष्टि को हटा देता है
• Set<Map.Entry<K,V>> entrySet() इस मानचित्र में निहित मैपिंग का एक सेट दृश्य लौटाता है
• शून्य forEach(BiConsumer<? सुपर K,? सुपर V> क्रिया) इस मानचित्र में प्रत्येक प्रविष्टि के लिए दी गई क्रिया को तब तक निष्पादित करता है जब तक कि सभी प्रविष्टियां संसाधित नहीं हो जाती हैं या कार्रवाई एक अपवाद को फेंक देती है।
• Object getOrDefault(Object key, V defaultValue) वह मान देता है जिस पर निर्दिष्ट कुंजी को मैप किया गया है। यदि मानचित्र में कुंजी रिटर्न डिफ़ॉल्ट वैल्यू के लिए मैपिंग नहीं है।
• सेट <के> कीसेट () मानचित्र में निहित कुंजियों का एक सेट दृश्य लौटाता है
• बूलियन रिमूवएल्डेस्टएंट्री(मैप.एंट्री<के,वी> ज्येष्ठ) सही रिटर्न देता है यदि इस मानचित्र को अपनी सबसे बड़ी प्रविष्टि को हटा देना चाहिए
• void replaceAll(BiFunction<? super K,? super V,? extends V> function) प्रत्येक प्रविष्टि मान को उस प्रविष्टि पर दिए गए फ़ंक्शन को लागू करने के परिणाम के साथ बदल देता है जब तक कि सभी प्रविष्टियों को संसाधित नहीं किया जाता है या फ़ंक्शन एक अपवाद फेंकता है।
• संग्रह <v> मान () मानचित्र में निहित मानों का संग्रह दृश्य लौटाता है

लिंक्ड हैश मैप उदाहरण

import java.util.LinkedHashMap;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;
   public class HashLinkedListExample {
       public static void main(String args[]) {
           // LinkedHashMap Declaration
           LinkedHashMap<Integer, String> myLinkedHashMap =
                   new LinkedHashMap<Integer, String>();

           //Adding elements into LinkedHashMap
           myLinkedHashMap.put(7, "Johnny");
           myLinkedHashMap.put(12, "Rick");
           myLinkedHashMap.put(1, "Kyle");
           myLinkedHashMap.put(5, "Percy");
           myLinkedHashMap.put(85, "Sebastian");

           // Generate a Set of entries
           Set set = myLinkedHashMap.entrySet();

           // Display and print out the nodes  of LinkedHashMap
           Iterator iterator = set.iterator();
           while(iterator.hasNext()) {
               Map.Entry me = (Map.Entry)iterator.next();
               System.out.print("key: "+ me.getKey() +
                       " value: "+me.getValue()+"\n");
           }
           //print out HashLinkedMap on standard way:
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.put(21, "Ivy");
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.remove(12);
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.put(12, "Ronny");
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.put(1, "Stan");
           System.out.println(myLinkedHashMap);
       }
   }

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

key: 7 value: Johnny
key: 12 value: Rick
key: 1 value: Kyle
key: 5 value: Percy
key: 85 value: Sebastian
{7=Johnny, 12=Rick, 1=Kyle, 5=Percy, 85=Sebastian}
{7=Johnny, 12=Rick, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy}
{7=Johnny, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy}
{7=Johnny, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy, 12=Ronny}
{7=Johnny, 1=Stan, 5=Percy, 85=Sebastian, 21=Ivy, 12=Ronny}

हैश मैप, ट्री मैप, लिंक्ड हैश मैप तुलना

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

• हैश मैप कोई आदेश नहीं रखता है।
• ट्रीमैप कुंजियों के आरोही क्रम में प्रविष्टियों को सॉर्ट करता है।
• LinkedHashMap सम्मिलन क्रम को बनाए रखता है।

अशक्त कुंजियाँ:

• हैश मैप और लिंक्ड हैश मैप एक शून्य कुंजी रखने की अनुमति देता है।
• LinkedHashMap कुंजी के प्राकृतिक क्रम का उपयोग करने के मामले में अशक्त कुंजियों की अनुमति नहीं देता है या तुलनित्र अशक्त लेज़ पर तुलना का समर्थन नहीं करता है।

आइए एक जावा मानचित्र का उदाहरण लें जिसमें इस आलेख में समीक्षा किए गए सभी तीन कार्यान्वयन शामिल हैं:

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.TreeMap;

public class CompMapImpl {


    public static void main(String[] args) {
        HashMap<Integer, String> hashMap = new HashMap<>();
        TreeMap<Integer, String> treeMap = new TreeMap<>();
        LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<>();
        hashMap.put(5, "Ivy");
        hashMap.put(null, "Joker");
        hashMap.put(1, "First");
        hashMap.put(2, "Kyle");
        hashMap.put(-2, "Paul");
        hashMap.put(3, "Sandy");


        treeMap.put(5, "Ivy");
        //treeMap.put(null,"Joker");
        treeMap.put(1, "First");
        treeMap.put(2, "Kyle");
        treeMap.put(-2, "Paul");
        treeMap.put(3, "Sandy");

        linkedHashMap.put(5, "Ivy");
        linkedHashMap.put(null, "Joker");
        linkedHashMap.put(1, "First");
        linkedHashMap.put(2, "Kyle");
        linkedHashMap.put(-2, "Paul");
        linkedHashMap.put(3, "Sandy");
        System.out.println("HashMap");
        System.out.println(hashMap);
        System.out.println("TreeMap");
        System.out.println(treeMap);
        System.out.println("LinkedHashMap");
        System.out.println(linkedHashMap);


        LinkedHashMap<String, String> linkedHashMap1= new LinkedHashMap<> ();
        linkedHashMap1.put(null, "Andy");
        System.out.println(linkedHashMap1);
    }
}

यहाँ इस कार्यक्रम को चलाने का परिणाम है:

HashMap
{null=Joker, 1=First, -2=Paul, 2=Kyle, 3=Sandy, 5=Ivy}
TreeMap
{-2=Paul, 1=First, 2=Kyle, 3=Sandy, 5=Ivy}
LinkedHashMap
{5=Ivy, null=Joker, 1=First, 2=Kyle, -2=Paul, 3=Sandy}
{null=Andy}

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