Java मध्ये नकाशा इंटरफेस

जावा मॅप इंटरफेस काय आहे

जावा मॅप इंटरफेस हा जावा कलेक्शन फ्रेमवर्कचा एक भाग आहे, परंतु तो कलेक्शन इंटरफेसचा उपप्रकार नाही. म्हणून ते वेगळ्या पद्धतीने वागते, म्हणा, सूची किंवा इतर संग्रहित वस्तूंच्या तुलनेत. Map<Key, Value> चा प्रत्येक घटक मुख्य-मूल्य जोडीचे प्रतिनिधित्व करतो. की आणि मूल्य दोन्ही काही वस्तू आहेत. विशिष्ट नकाशातील सर्व की अद्वितीय आहेत, तर मूल्ये नाहीत, म्हणून त्यांची डुप्लिकेट केली जाऊ शकते. तुम्ही Java मधील नकाशाचा विचार करू शकता जसे की एक प्रकारचा शब्दकोष किंवा ऑनलाइन-शॉप कॅटलॉग, जिथे तुम्हाला त्याची अद्वितीय अनुक्रमणिका वापरून कोणतीही वस्तू सापडेल. की ही नकाशातील मूल्याची एक अद्वितीय ओळखकर्ता आहे. उदाहरणार्थ मॅप<स्ट्रिंगमध्ये, आयटम> स्ट्रिंग हा ऑनलाइन दुकानातील काही आयटमचा आयडी आहे. कागदपत्रांनुसार नकाशामध्ये पुढील उप-इंटरफेस आहेत:

बंधने ;
• समवर्ती नकाशा<K,V> ;
• समवर्ती नेव्हीगेबल नकाशा<K,V> ;
• LogicalMessageContext ;
• MessageContext ;
• नेव्हिगेटेबल नकाशा<K,V> ;
• SOAPMessageContext ;
• क्रमवारी लावलेला नकाशा<K,V> .

आणि वर्गांची अंमलबजावणी:

• AbstractMap
• विशेषता
• AuthProvider
• समवर्ती हॅशमॅप
• समवर्तीSkipListMap
• EnumMap
• हॅशमॅप
• हॅशटेबल
• IdentityHashMap
• LinkedHashMap
• प्रिंटरस्टेट कारणे
• गुणधर्म
• प्रदाता
• रेंडरिंग संकेत
• साधे बाइंडिंग्ज
• TabularDataSupport
• ट्रीमॅप
• यूआयडीफॉल्ट्स
• WeakHashMap

• Java AbstractMap हा एक अमूर्त वर्ग आहे जो बहुतेक नकाशा इंटरफेस लागू करतो.
• Java HashMap हे हॅश टेबल वापरून की-व्हॅल्यू जोड्या संग्रहित करण्यासाठी डेटा स्ट्रक्चर आहे.
• Java TreeMap हे ट्री वापरण्यासाठी डेटा स्ट्रक्चर आहे, म्हणजे क्रमवारी केलेल्या कीसह प्रदर्शित करा.
• कमकुवत कीसह हॅश टेबल वापरण्यासाठी WeakHashMap , यापुढे वापरल्या जात नसतील तर कचरा संग्राहकाद्वारे हटवल्या जाऊ शकतील अशा मूल्यांसह प्रदर्शित करा.
• LinkedHashMap हा घटक जोडण्याच्या क्रमासह नकाशा आहे, जो समाविष्ट करण्याच्या क्रमाने पुनरावृत्तीला अनुमती देतो.
• EnumMap एनम की सह वापरण्यासाठी अॅबस्ट्रॅक्टमॅप वर्ग वाढवते .
IdentityHashMap दस्तऐवजांची तुलना करताना संदर्भीय समतुल्य तपासणीचा वापर करते, समान() पद्धतीऐवजी == ऑपरेशन वापरून तुलना करताना की सह मॅपिंग करते

येथे आम्हाला मॅप इंटरफेसच्या सर्वात लोकप्रिय अंमलबजावणीमध्ये स्वारस्य आहे: हॅशमॅप, ट्रीमॅप आणि लिंक्डहॅशमॅप. तसे, नकाशा घटकांचा क्रम विशिष्ट अंमलबजावणीवर अवलंबून असतो. म्हणा, TreeMap आणि LinkedHashMap मध्ये घटकांचा अंदाज लावता येण्याजोगा क्रम आहे, तर HashMap मध्ये नाही.

नकाशा पद्धती

कोणत्याही नकाशाचे मुख्य कार्य म्हणजे घटक समाविष्ट करणे, काढणे आणि शोधणे.

• सार्वजनिक ऑब्जेक्ट पुट (ऑब्जेक्ट की, ऑब्जेक्ट व्हॅल्यू) नकाशामध्ये एक घटक समाविष्ट करते.
• पब्लिक व्हॉइड पुट ऑल (नकाशा नकाशा) नकाशामध्ये निर्दिष्ट नकाशा समाविष्ट करते.
• पब्लिक ऑब्जेक्ट रिमूव्ह (ऑब्जेक्ट की) निर्दिष्ट कीनुसार एंट्री हटवते.
• पब्लिक ऑब्जेक्ट गेट(ऑब्जेक्ट की) निर्दिष्ट कीसाठी मूल्य परत करते.
• सार्वजनिक बूलियन समाविष्टकी (ऑब्जेक्ट की) या नकाशावरून निर्दिष्ट की शोधते
• public Set keySet() एक Set दृश्य देते ज्यामध्ये सर्व की असतात
• public Set entrySet() सर्व की आणि व्हॅल्यूसह सेट व्ह्यू मिळवते.

हॅशमॅप म्हणजे काय

हॅशमॅप म्हणजे काय? हे Map<Key,Value> इंटरफेसचे सर्वात लोकप्रिय अंमलबजावणी आहे. ही डेटा रचना हॅशिंग तत्त्वावर आधारित आहे.

हॅशमॅप कार्याचे मुख्य तत्त्व: हॅशिंग

हॅशमॅप म्हणजे काय आणि ते कसे कार्य करते हे समजून घेण्यासाठी, प्रथम हॅशिंग आणि हॅश फंक्शन्सबद्दल बोलूया. हॅश फंक्शन हे गणितीय अर्थाने फक्त एक फंक्शन आहे. त्यामुळे काही इनपुट व्हॅल्यू (ऑब्जेक्ट, डेटाचा तुकडा) असते आणि फंक्शन योग्य नियम वापरून आउटपुट व्हॅल्यूमध्ये रूपांतरित करते - हॅश. बर्‍याचदा हॅश ही योग्य लांबीची हेक्साडेसिमल संख्या असते. रूपांतर प्रक्रियांचे नियम भिन्न असू शकतात, परंतु ते खालील तत्त्वांच्या अधीन आहेत:

1. विशिष्ट इनपुट (ऑब्जेक्ट) मध्ये विशिष्ट हॅश कोड असतो.
2. जर दोन वस्तू समान असतील तर त्यांचे हॅश कोड देखील समान असतील. उलट सत्य नाही.
3. हॅश कोड भिन्न असल्यास, ऑब्जेक्ट्स निश्चितपणे समान नसतात.
4. काहीवेळा भिन्न वस्तूंमध्ये समान हॅश कोड असू शकतो. "टक्कर" नावाची ही एक अत्यंत संभाव्य घटना आहे आणि चांगल्या दर्जाच्या हॅश फंक्शनने टक्कर होण्याची शक्यता कमी केली पाहिजे.

Java मध्ये, प्रत्येक ऑब्जेक्टला हॅश कोड असतो. हे ऑब्जेक्ट क्लासच्या हॅशकोड पद्धतीने मोजले जाते, सर्व Java ऑब्जेक्ट्सचे पॅरेंटल क्लास. सहसा, विकासक त्यांच्या स्वत: च्या वर्गासाठी ही पद्धत अधिलिखित करतात तसेच त्यांच्याशी संबंधित पद्धती समान असतात .

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

म्हणून वर्ग HashMap<K,V> प्रत्येक नकाशा अंमलबजावणीमध्ये की आणि मूल्ये असतात. हे हॅशिंग तत्त्वे वापरून की संग्रहित करते. हॅशमॅपच्या आत की-व्हॅल्यू जोड्या "बकेट्स" मध्ये संग्रहित केल्या जातात, या बादल्या एकत्रितपणे "टेबल" बनवतात, लिंक केलेल्या सूचींचा अंतर्गत अॅरे आणि त्याचा प्रारंभिक आकार 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) नकाशामध्ये की व्हॅल्यू मॅपिंग समाविष्ट करते;
• ऑब्जेक्ट रिमूव्ह (ऑब्जेक्ट की) जर उपस्थित असेल तर या नकाशावरून निर्दिष्ट कीसाठी मॅपिंग काढून टाकते;
• void clear() हॅशमॅपमधून सर्व की-व्हॅल्यू जोड्या काढून टाकते;
• ऑब्जेक्ट क्लोन() की आणि व्हॅल्यू क्लोन न करता या हॅशमॅप उदाहरणाची उथळ प्रत देते;
• निर्दिष्ट की नकाशामध्ये आढळल्यास boolean containsKey(ऑब्जेक्ट की) सत्य मिळवते, नसल्यास खोटी;
• निर्दिष्ट की नकाशामध्ये आढळल्यास बुलियन समाविष्ट व्हॅल्यू(ऑब्जेक्ट व्हॅल्यू) सत्य मिळवते, नसल्यास खोटी;
• बूलियन isEmpty() नकाशा रिकामा असल्यास सत्य मिळवते, नसल्यास खोटे देते;
• सेट keySet() नकाशावरून आणलेल्या कळांचा संच परत करतो;
• int size() की-व्हॅल्यू मॅपिंगचे प्रमाण परत करते;
• संकलन मूल्ये() नकाशाच्या मूल्यांचा संग्रह परत करते;
• ऑब्जेक्ट रिमूव्ह (ऑब्जेक्ट की) निर्दिष्ट कीसाठी की-व्हॅल्यू जोडी काढून टाकते;
• void putAll(Map m) नकाशाचे सर्व घटक इतर नकाशावर कॉपी करते.

Java HashMap उदाहरण

ते कसे कार्य करते हे दाखवण्यासाठी Java HashMap उदाहरणासह एक प्रोग्राम तयार करू:

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 त्याच्या नोंदी त्याच्या कीच्या नैसर्गिक क्रमानुसार क्रमवारीत ठेवते. संख्यांसाठी नैसर्गिक म्हणजे चढत्या क्रमाने, स्ट्रिंगसाठी - वर्णक्रमानुसार. तुम्हाला ऑर्डर देण्याचे तर्क बदलायचे असल्यास तुम्ही तुलनाकर्ता वापरू शकता. नैसर्गिक पद्धतीने वस्तूंची क्रमवारी लावणे हा TreeMap चा एक मोठा फायदा आहे, तसेच भिन्न फिल्टर आणि परिस्थिती वापरून काही वस्तू शोधणे हा आहे.

ट्रीमॅप पद्धती

• ऑब्जेक्ट गेट(ऑब्जेक्ट की) संबंधित कीचे मूल्य परत करते;
• ऑब्जेक्ट पुट (ऑब्जेक्ट की, ऑब्जेक्ट मूल्य) नकाशामध्ये मॅपिंग समाविष्ट करते;
• ऑब्जेक्ट रिमूव्ह (ऑब्जेक्ट की) ट्रीमॅपमध्ये असल्यास या कीचे मॅपिंग काढून टाकते;
• जर या नकाशामध्ये निर्दिष्ट कीसाठी मॅपिंग असेल तर बुलियन containsKey(ऑब्जेक्ट की) सत्य दर्शवते;
• जर ट्रीमॅपने निर्दिष्ट मूल्यासाठी एक किंवा अधिक की मॅप केले तर बुलियन समाविष्ट व्हॅल्यू(ऑब्जेक्ट व्हॅल्यू) खरे मिळवते;
• ऑब्जेक्ट firstKey() सध्या क्रमवारी केलेल्या नकाशामध्ये पहिली की परत करते;
• ऑब्जेक्ट lastKey() सध्या क्रमवारी केलेल्या नकाशामध्ये शेवटची की परत करते;
• void putAll(नकाशा नकाशा) निर्दिष्ट नकाशावरून नकाशावर सर्व मॅपिंग कॉपी करते;
• Set entrySet() मॅपिंगचे सेट दृश्य परत करते
• int size() की-व्हॅल्यू मॅपिंगचे प्रमाण परत करते
• कलेक्शन व्हॅल्यू() व्हॅल्यूजचे कलेक्शन व्ह्यू देते
• ऑब्जेक्ट क्लोन() TreeMap ची उथळ प्रत परत करते
• void clear() TreeMap वरून सर्व मॅपिंग काढून टाकते
• सॉर्टेडमॅप हेडमॅप(ऑब्जेक्ट की_व्हॅल्यू) पॅरामीटर key_value पेक्षा कमी नकाशाच्या भागाचे दृश्य देते
• Set keySet() ट्रीमॅपमध्‍ये असलेल्या कीजचे सेट दृश्‍य देते
• सॉर्टेडमॅप सबमॅप(K fromKey, K toKey) या नकाशाच्या त्या भागाचे दृश्य देते ज्याच्या की पासून की पासून, सर्वसमावेशक, toKey पर्यंत, अनन्य
• Object firstKey() TreeMap वरून पहिली की परत करते.

TreeMap उदाहरण

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 ही एक डेटा संरचना आहे जी लिंक केलेल्या सूची आणि हॅश नकाशे एकत्र करते. खरंच, LinkedHashMap हॅशमॅप वर्ग वाढवते आणि नकाशा इंटरफेस लागू करते, परंतु लिंक केलेल्या सूचीबद्दल काय आहे? LinkedHashMap ची घोषणा:

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

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

• शीर्षलेख हे दुहेरी लिंक केलेल्या सूचीचे प्रमुख आहे. आरंभिकरण दरम्यान, ते स्वतःला सूचित करते
• एक्सेसऑर्डर इटरेटर वापरून घटकांमध्ये प्रवेश कसा मिळवायचा हे सूचित करते. खरे असल्यास, शेवटच्या प्रवेशाच्या क्रमाने. असत्य असल्यास, घटक घातलेल्या क्रमाने प्रवेश असेल.

ही लिंक केलेली यादी पुनरावृत्ती क्रम परिभाषित करते. सहसा, नकाशामध्ये की घालण्याचा क्रम असतो.

LinkedHashMap पद्धती

• ऑब्जेक्ट गेट(ऑब्जेक्ट की) निर्दिष्ट की मॅप केलेले मूल्य परत करते किंवा या नकाशामध्ये कीसाठी कोणतेही मॅपिंग नसल्यास शून्य
• void clear() नकाशावरून सर्व मॅपिंग काढून टाकते.
• जर निर्दिष्ट घटक एक किंवा अधिक की द्वारे मॅप केला असेल तर बूलियन समावेशकी(ऑब्जेक्ट की) सत्य मिळवते
• बूलियन रिमूव्हएल्डेस्ट एंट्री(मॅप.एन्ट्री एल्डेस्ट) जर नकाशाने त्याची सर्वात जुनी एंट्री नकाशावरून काढून टाकली तर ती सत्य परत येईल
• Set<Map.Entry<K,V>> entrySet() या नकाशामध्ये असलेल्या मॅपिंगचे सेट व्ह्यू देते
• void forEach(BiConsumer<? super K,? super V> action) या नकाशातील प्रत्येक एंट्रीसाठी दिलेली क्रिया सर्व नोंदींवर प्रक्रिया होईपर्यंत किंवा कृती अपवाद करत नाही तोपर्यंत करते.
• ऑब्जेक्ट getOrDefault(ऑब्जेक्ट की, V defaultValue) निर्दिष्ट की मॅप केलेले मूल्य परत करते. नकाशामध्ये की साठी मॅपिंग नसल्यास डीफॉल्ट व्हॅल्यू मिळते.
• Set<K> keySet() नकाशामध्ये समाविष्ट असलेल्या कळांचे सेट दृश्य परत करते
• बुलियन रिमूव्हएल्डेस्ट एंट्री(मॅप.एंट्री<के,वी> सर्वात जुनी) जर या नकाशाने त्याची सर्वात जुनी एंट्री काढून टाकली असेल तर ती सत्य दर्शवते
• void replaceAll(BiFunction<? super K,? super V,? extends V> function) प्रत्येक एंट्री व्हॅल्यूला त्या एंट्रीवर दिलेले फंक्शन इनव्हॉईंग केल्यामुळे सर्व एंट्रीवर प्रक्रिया होईपर्यंत किंवा फंक्शनने अपवाद फेकून दिलेला परिणाम बदलतो.
• संकलन<v>values() नकाशामध्ये समाविष्ट असलेल्या मूल्यांचे संकलन दृश्य देते

LinkedHashMap उदाहरण

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}

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

हॅशमॅप, ट्रीमॅप आणि लिंक्डहॅशमॅप हे मॅप इंटरफेसची अंमलबजावणी आहेत. हॅशमॅप आणि लिंक्डहॅशमॅप डेटा स्ट्रक्चर्स आहेत ज्या की हॅश करतात. शोध वृक्ष आयोजित करण्यासाठी TreeMap त्याच्या की चा नैसर्गिक क्रम वापरतो. ऑर्डर:

• हॅशमॅप कोणताही क्रम राखत नाही.
• ट्रीमॅप कीजच्या चढत्या क्रमाने नोंदींची क्रमवारी लावते.
• LinkedHashMap समाविष्ट करण्याचा क्रम राखतो.

शून्य की:

• हॅशमॅप आणि लिंक्डहॅशमॅप एक शून्य की ठेवण्याची परवानगी देतात.
• लिंक्डहॅशमॅप नॅचरल ऑर्डरिंग वापरत असल्यास किंवा कम्पॅरेटर नल लीजवर तुलना करण्यास समर्थन देत नसल्यास नल कीला परवानगी देत ​​नाही.

या लेखात पुनरावलोकन केलेल्या तीनही अंमलबजावणीचा समावेश असलेल्या Java नकाशाचे उदाहरण घेऊया:

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}

जसे आपण पाहू शकतो, हॅशमॅपमधील घटकांचा क्रम स्पष्ट नाही, ट्रीमॅपमध्ये ते कीजवर अवलंबून असते, लिंक्डहॅशमॅपमध्ये ते समाविष्ट करण्याच्या क्रमाबद्दल असते. जर आपण linkedHashMap मध्ये null key टाकण्याचा प्रयत्न केला तर आपल्याला NullPointerException मिळेल, पण linkedHashMap1 मध्ये, जिथे की स्ट्रिंग आहेत, आपण ते करू शकतो. हॅश नकाशा ही सर्वोत्तम सामान्य-उद्देश नकाशा अंमलबजावणी आहे. हे जास्तीत जास्त शोध गती, जलद स्टोरेज आणि पुनर्प्राप्ती ऑपरेशन्स प्रदान करते, परंतु तुम्ही त्याच्या गोंधळलेल्या क्रमाबद्दल लक्षात ठेवावे. लिंक केलेला हॅश मॅप हॅशमॅप फायदे मिळवतो आणि की साठी ऑर्डर मिळवतो. तथापि, त्यात लिंक्डलिस्ट आहे, जी मेमरीच्या दृष्टीने तुलनेने महाग आहे. हे हॅशमॅप पेक्षा धीमे आहे आणि लिंक्ड लिस्ट कायम ठेवल्यामुळे जोडा/काढण्यासाठी थोडा धीमा आहे. झाडाचा नकाशा चढत्या क्रमाने लावलेल्या कळ साठवतो. तथापि, तुम्ही जे शिकलात ते बळकट करण्यासाठी, आम्ही तुम्हाला आमच्या Java कोर्समधील व्हिडिओ धडा पाहण्याचा सल्ला देतो