कार्यान्वयन और उदाहरण के साथ जावा मैप इंटरफ़ेस ट्यूटोरियल

java map interface tutorial with implementation examples

समस्याओं को खत्म करने के लिए हमारे साधन का प्रयास करें

ऑपरेटिंग सिस्टम का चयन करें प्रक्षेपण का एक कार्यक्रम चुनें (वैकल्पिक रूप से)

अपनी समस्या का वर्णन करें

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

आपको मानचित्र इंटरफ़ेस की मूल बातें, मानचित्र इंटरफ़ेस द्वारा समर्थित तरीके और मानचित्र इंटरफ़ेस से संबंधित अन्य विशिष्ट शर्तें पता चलेंगी।

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

=> यहाँ सभी जावा ट्यूटोरियल की जाँच करें।

जावा में मैप इंटरफ़ेस

आप क्या सीखेंगे:

जावा में मैप्स
मानचित्र के तरीके
जावा मानचित्र कार्यान्वयन
निष्कर्ष
- अनुशंसित पाठ

जावा में मैप्स

जावा में नक्शा java.util.map इंटरफ़ेस का एक हिस्सा है। मानचित्र इंटरफ़ेस संग्रह इंटरफ़ेस का हिस्सा नहीं है और यही कारण है कि मानचित्र अन्य संग्रह से अलग हैं।

मानचित्र इंटरफ़ेस का सामान्य पदानुक्रम नीचे दिखाया गया है।

नक्शा इंटरफ़ेस के सामान्य पदानुक्रम

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

ये मानचित्र प्रकार नीचे दिए गए हैं:

कक्षा	विवरण
हटाना	V निष्कासन (ऑब्जेक्ट कुंजी)	दी गई कुंजी के लिए एक मानचित्र प्रविष्टि हटाएं
LinkedHashMap	HashMap वर्ग से फैली हुई है। यह नक्शा प्रविष्टि क्रम को बनाए रखता है
हैश मैप	मानचित्र इंटरफ़ेस लागू करें। HashMap द्वारा कोई आदेश नहीं रखा गया है।
ट्री-मैप	दोनों मानचित्र और सॉर्ट किए गए इंटरफ़ेस को लागू करता है। ट्रीपॉपर एक आरोही क्रम बनाए रखता है।

मैप्स के बारे में याद करने के लिए अंक।

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

जावा में एक नक्शा बनाएँ

जावा में एक नक्शा बनाने के लिए, पहले, हमें अपने कार्यक्रम में इंटरफ़ेस को शामिल करना होगा। हम मानचित्र कार्यक्षमता को आयात करने के लिए कार्यक्रम में निम्नलिखित कथनों में से एक का उपयोग कर सकते हैं।

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

हमें मानचित्र के एक ठोस कार्यान्वयन को तुरंत करने की आवश्यकता है क्योंकि यह एक इंटरफ़ेस है।

निम्नलिखित कथन जावा में एक मानचित्र बनाते हैं।

Map hash_map = new HashMap(); Map tree_map = new TreeMap();

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

Map myMap = new HashMap();

उपरोक्त परिभाषा में मान के रूप में टाइप स्ट्रिंग और ऑब्जेक्ट्स की कुंजियाँ होंगी।

जावा में एक मैप को इनिशियलाइज़ करें

इसे निम्न विधियों का उपयोग करके आरंभ किया जा सकता है:

(1) संग्रह का उपयोग करना

जावा कलेक्शंस क्लास में फ़ैक्टरी विधियाँ हैं जिनका उपयोग मानचित्रों सहित संग्रह को आरम्भ करने के लिए किया जा सकता है।

मानचित्र को इनिशियलाइज़ करने के लिए इस्तेमाल किए जाने वाले कुछ तरीके इस प्रकार हैं:

(1) संग्रह। खाली नक्शा ()

Collections.EmptyMap () एक क्रमिक और अपरिवर्तनीय मानचित्र देता है जो खाली है। उदाहरण के लिए, कोड की निम्नलिखित पंक्ति,

Map myMap = Collections.EMPTY_MAP;

यह एक खाली नक्शा बनाएगा। उपरोक्त विधि ed अनियंत्रित असाइनमेंट चेतावनी ’को फेंक सकती है और इस प्रकार हम निम्न प्रकार के सुरक्षित प्रकार का भी उपयोग कर सकते हैं।

Map myMap = Collections.emptyMap ();

(2) संग्रह।

विधि unModifiableMap () एक तर्क के रूप में एक और मानचित्र लेता है और मूल मानचित्र का एक अपरिवर्तनीय दृश्य बनाता है।

Map myMap = Collections.EMPTY_MAP; Map map_unmodifiable = Collections.unmodifiableMap (myMap);

(३) संग्रह.सिंघटन मैप ()

संग्रह वर्ग एक फैक्ट्री विधि प्रदान करता है leton सिंगलटन मैप () 'जो एक अपरिवर्तनीय सिंगलटन मानचित्र बनाता है जिसमें केवल एक प्रविष्टि होती है।

Map singleton_map = Collections.singletonMap('CHN', 'Beijing');

# 2) जावा 8 का उपयोग करना

हम जावा 8 स्ट्रीम एपीआई विधियों से डेटा की एक स्ट्रीम प्राप्त कर सकते हैं और कलेक्टरों का उपयोग कर नक्शे का निर्माण कर सकते हैं।

नक्शे बनाने की कुछ विधियाँ निम्नलिखित हैं:

(1) संग्राहक.toMap ()

हम एक स्ट्रीम इकट्ठा करते हैं और फिर एक नक्शा बनाने के लिए कलेक्टरों (मानचित्र) का उपयोग करते हैं।

 Map map = Stream.of(new String()(){{'USA', 'Washington'},   {'United Kingdom', 'London'}    }).collect(Collectors.toMap(p -> p(0), p -> p(1)));

उपरोक्त कथन जावा 8 स्ट्रीम से एक मानचित्र बनाता है।

(2) संग्राहक

इसमें, हम toMap () विधि को अनुकूलित करते हैं जो संग्रहकर्ता को संग्रहणीय () पद्धति का उपयोग करके एक अपरिवर्तनीय मानचित्र बनाने की अनुमति देता है।

 Map immutableMap = Stream.of(new String()(){   {'USA', 'Washington'}, {'United Kingdom', 'London”}   }).collect(Collectors.collectingAndThen(Collectors.toMap(p -> p (0), p -> p(1)),   Collections::unmodifiableMap));

# 3) मैप इंटरफेस के पुट विधि का उपयोग करना

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

# 4) डबल ब्रेस इनिशियलाइज़ेशन का उपयोग करना

तकनीक 'डबल ब्रेस इनिशियलाइज़ेशन' एक आंतरिक वर्ग बनाता है। यह वर्ग अनाम है और इसमें एक उदाहरण इनिशियलाइज़र है। यह एक पसंदीदा तकनीक नहीं है और इससे बचना चाहिए क्योंकि इसके परिणामस्वरूप मेमोरी लीक या क्रमांकन समस्याएं हो सकती हैं।

नीचे दिए गए कार्यक्रम में ऊपर चर्चा किए गए नक्शे को आरम्भ करने के विभिन्न तरीकों को दिखाया गया है।

import java.util.*; import java.util.stream.*; import java.util.stream.Collectors; public class Main { public static void main(String args()) { //using Collections //create an empty map Map emptymap = Collections.EMPTY_MAP; //create unmodifiable map using Collections Map unmodifiableMap = Collections.unmodifiableMap(emptymap); System.out.println('unmodifiableMap map values:' + unmodifiableMap); //singleton map Map singleton_map = Collections.singletonMap(10, ' TEN'); System.out.println('

singleton_map Map values:' + singleton_map); //using Java 8 //1. toMap method of collectors class Map map_cities = Stream.of(new String()(){ {'MH', 'Mumbai'}, {'CH', 'Chennai'}, {'DL', 'New Delhi'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); System.out.println('

map_cities values: ' + map_cities); //2. collectingAndThen method Map capitals_Map = Stream.of(new String()(){ {'MAH', 'Mumbai'}, {'GOA', 'Panaji'}, {'KAR', 'Bangaluru'} }).collect(Collectors.collectingAndThen (Collectors.toMap(p -> p(0), p -> p(1)), Collections::unmodifiableMap)); System.out.println('

capitals_Map values: ' + capitals_Map); //double brace initialization Map country_map = new HashMap(); country_map.put('USA', 'Washington'); country_map.put('UK', 'London'); country_map.put('IND', 'Delhi'); country_map.put('GER', 'Berlin'); System.out.println('

Map values:' + country_map); } }

आउटपुट:

unmodifiableMap मानचित्र मान: {}
सिंगलटन_मैप मैप मान: {10 = TEN}
map_cities मान: {CH = चेन्नई, DL = नई दिल्ली, महाराष्ट्र = मुंबई}
capitals_Map values: {MAH=Mumbai, GOA=Panaji, KAR=Bangaluru}
मानचित्र मान: {यूएसए = वाशिंगटन, जीईआर = बर्लिन, यूके = लंदन, IND = दिल्ली}

एक मानचित्र को आरंभीकृत करना

जावा में मानचित्र पर Iterate और मानचित्र मुद्रित करें

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

मानचित्र प्रविष्टियों को पार करने के लिए निम्न विधियों का उपयोग किया जाता है।

एंट्री इटरेटर का उपयोग करना

इस पद्धति में, हम एक प्रविष्टि सेट से एक प्रविष्टि पुनरावृत्ति प्राप्त करते हैं। फिर getKey और getValue तरीकों का उपयोग करते हुए, हम प्रत्येक मानचित्र प्रविष्टि के लिए कुंजी-मूल्य जोड़ी को पुनः प्राप्त करते हैं।

निम्न कार्यक्रम एक प्रविष्टि पुनरावृत्ति के उपयोग को दर्शाता है।

import java.util.*; import java.util.stream.*; import java.util.stream.Collectors; public class Main { public static void main(String args()) { //use toMap method of collectors class to populate the map Map map_cities = Stream.of(new String()(){ {'MH', 'Mumbai'}, {'CH', 'Chennai'}, {'DL', 'New Delhi'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); //transform map to set Set entries = map_cities.entrySet(); //declare an iterator Iterator iterator = entries.iterator(); System.out.println('The map entries are:'); System.out.println(' KEY VALUE'); //iterate and print key and value pairs. while(iterator.hasNext()) { Map.Entry entry = iterator.next(); System.out.println('	' + entry.getKey() + '	' +entry.getValue()); } } }

आउटपुट:

नक्शे की प्रविष्टियाँ हैं:
मौलिक मूल्य
सीएच चेन्नई
डीएल नई दिल्ली
MH Mumbai

प्रवेश द्वार का उपयोग करना

उपरोक्त कार्यक्रम में, हम एंट्रीसेट विधि का उपयोग करके नक्शे से एक प्रवेश पुनरावृत्ति प्राप्त करते हैं। फिर हम प्रवेश पुनरावृत्ति के हैनक्स्ट () पद्धति का उपयोग करके मानचित्र को पार करते हैं और कुंजी-मूल्य जोड़ी को प्रिंट करते हैं।

प्रत्येक लूप के लिए एक प्रविष्टि का उपयोग करना

यहां हम प्रत्येक लूप का उपयोग करके प्रविष्टिसेट को पार करते हैं और कार्यान्वयन नीचे दिखाया गया है।

import java.util.*; import java.util.stream.*; import java.util.stream.Collectors; public class Main { public static void main(String args()) { //use toMap method of collectors class to populate the map Map map_cities = Stream.of(new String()(){ {'MH', 'Mumbai'}, {'CH', 'Chennai'}, {'DL', 'New Delhi'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); System.out.println('The map entries are:'); System.out.println(' KEY VALUE'); //iterate using for each over entry set and print key and value pairs. for(Map.Entry entry : map_cities.entrySet()){ System.out.println('	' + entry.getKey() + '	' +entry.getValue()); } } }

आउटपुट:

नक्शे की प्रविष्टियाँ हैं:
मौलिक मूल्य
सीएच चेन्नई
डीएल नई दिल्ली
MH Mumbai

प्रत्येक लूप के लिए एक प्रविष्टि का उपयोग करना

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

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

हम नक्शा इंटरफ़ेस कक्षाओं पर चर्चा करते समय इन तरीकों पर विस्तार से चर्चा करेंगे।

निम्न तालिका मैप एपीआई द्वारा प्रदान की गई सभी विधियों को सूचीबद्ध करती है।

विधि का नाम	विधि प्रोटोटाइप	विवरण
प्राप्त	V मिलता है (ऑब्जेक्ट कुंजी)	दी गई कुंजी के लिए वस्तु या मान लौटाता है
लगाया हुआ	V put (ऑब्जेक्ट कुंजी, ऑब्जेक्ट मान)	मानचित्र में कुंजी-मूल्य प्रविष्टि डालें
सभी रखें	शून्य putAll (मानचित्र मानचित्र)	मानचित्र में दी गई मानचित्र प्रविष्टियाँ डालें। दूसरे शब्दों में प्रतियां या एक नक्शा क्लोन करता है।
चाबीगुछा	सेट कीसेट ()	रिटर्न मानचित्र का दृश्य सेट करता है।
एंट्रीसेट	सेटएंट्रीसेट ()	रिटर्न किसी दिए गए नक्शे के लिए दृश्य सेट करते हैं
मूल्यों	संग्रह मान ()	नक्शे में मूल्यों का संग्रह दृश्य लौटाता है।
आकार	int आकार ()	नक्शे में प्रविष्टियों की संख्या लौटाता है
स्पष्ट	शून्य स्पष्ट ()	नक्शे को साफ करता है
खाली है	बूलियन इम्प्टी ()	जाँचता है कि क्या मानचित्र खाली है और यदि हाँ तो सही है।
सम्‍मिलित है	बूलियन समरूपता (वस्तु मान)	यदि मानचित्र में दिए गए मान के बराबर मूल्य है तो यह सही है
होता है	बूलियन होता हैकेय (ऑब्जेक्ट कुंजी)	यदि मानचित्र में दी गई कुंजी मौजूद है, तो सही है
बराबरी	बूलियन बराबर (ऑब्जेक्ट ओ)	मानचित्र के साथ निर्दिष्ट ऑब्जेक्ट ओ की तुलना करता है
हैश कोड	int हैशकोड ()	मैप के लिए हैश कोड लौटाता है
प्रत्येक के लिए	शून्य forEach (BiConsumer कार्रवाई)	मानचित्र में प्रत्येक प्रविष्टि के लिए दी गई क्रिया करता है
getOrDefault	V getOrDefault (ऑब्जेक्ट कुंजी, V defaultValue)	दिए गए कुंजी या उसके डिफ़ॉल्ट मान के लिए निर्दिष्ट मान देता है यदि कुंजी मौजूद नहीं है
हटाना	बूलियन निकालें (ऑब्जेक्ट कुंजी, ऑब्जेक्ट मान)	निर्दिष्ट कुंजी और मान निकालता है
बदलने के	V प्रतिस्थापित (K कुंजी, V मान)	दिए गए कुंजी को निर्दिष्ट मान के साथ बदल देता है
बदलने के	बूलियन की जगह (K कुंजी, V oldValue, V newValue)	किसी दिए गए कुंजी के नए मूल्य के साथ पुराने मूल्य को बदल देता है
सबको बदली करें	शून्य रिप्लेसमेंट (बायफ़ंक्शन फ़ंक्शन)	सभी मानचित्र प्रविष्टियों को बदलने के लिए दिए गए फ़ंक्शन को आमंत्रित करता है
putIfAbsent	V putIfAbsent (K कुंजी, V मान)	दी गई कुंजी को सम्मिलित करता है, तभी मान दें जब वह पहले से मौजूद नहीं है
गणना करना	V कंप्यूट (K कुंजी, BiFunction रीमैपिंग फ़ंक्शन)	मानचित्रण फ़ंक्शन को निर्दिष्ट कुंजी और मान के लिए मानचित्रण की गणना करता है।
computeIfAbsent	V computeIfAbsent (K कुंजी, फंक्शन मैपिंग फंक्शन)	मैपिंग फ़ंक्शन का उपयोग करके दिए गए कुंजी के लिए मान की गणना करें यदि पहले से मौजूद नहीं है।
computeIfPresent	V computeIfPresent (K कुंजी, BiFunction remappingFunction)	दिए गए रीमैपिंग फ़ंक्शन के साथ दिए गए कुंजी के लिए नए मानचित्रण की गणना करता है यदि कुंजी मान पहले से मौजूद है
जाओ	V मर्ज (K कुंजी, V मान, BiFunction रीमैपिंग फ़ंक्शन)	किसी दिए गए कुंजी को उस मूल्य के साथ संबद्ध करता है यदि वह पहले से संबद्ध नहीं है या शून्य मान से संबद्ध है।

उपर्युक्त सभी तरीके मानचित्र इंटरफ़ेस द्वारा समर्थित हैं। ध्यान दें कि छायांकित दिखाई देने वाले तरीके जावा 8 में शामिल किए गए नए तरीके हैं।

जावा मानचित्र कार्यान्वयन

निम्नलिखित कार्यक्रम जावा में एक मानचित्र उदाहरण को लागू करता है। यहां हम ऊपर चर्चा की गई अधिकांश विधियों का उपयोग करते हैं।

उदाहरण विभिन्न प्राप्त संचालन, पुट और संचालन को प्रदर्शित करता है।

import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; import java.util.Set; public class Main { public static void main(String() args) { //create a map Map country_map = new HashMap(); //assign values to the map country_map.put('IND', 'India'); country_map.put('SL', 'Srilanka'); country_map.put('CHN', 'China'); country_map.put('KOR', 'Korea'); country_map.put(null, 'Z'); // null key country_map.put('XX', null); // null value String value = country_map.get('CHN'); // get System.out.println('Key = CHN, Value : ' + value); value = country_map.getOrDefault('XX', 'Default Value'); //getOrDefault System.out.println('
Key = XX, Value : ' + value); boolean keyExists = country_map.containsKey(null); //containsKey boolean valueExists = country_map.containsValue('Z'); //containsValue System.out.println('
null keyExists : ' + keyExists + ', null valueExists= ' + valueExists); Set entrySet = country_map.entrySet(); //entrySet System.out.println('
entry set for the country_map: ' + entrySet); System.out.println('
Size of country_map : ' + country_map.size()); //size Map data_map = new HashMap(); data_map.putAll(country_map); //putAll System.out.println('
data_map mapped to country_map : ' + data_map); String nullKeyValue = data_map.remove(null); //remove System.out.println('
null key value for data_map : ' + nullKeyValue); System.out.println('
data_map after removing null key = ' + data_map); Set keySet = country_map.keySet(); //keySet System.out.println('
data map keys : ' + keySet); Collection values = country_map.values(); //values System.out.println('
data map values : ' + values); country_map.clear(); //clear System.out.println('
data map after clear operation, is empty :' + country_map.isEmpty()); } }

आउटपुट:

की = सीएचएन, मूल्य: चीन
की = XX, मान: अशक्त
null keyExists: true, null valueExists = true
देश के लिए प्रविष्टि सेट_मैप: (null = Z, XX = null, CHN = चीन, SL = श्रीलंकाई, IND = भारत, KOR = कोरिया)
देश_ आकार: 6
data_map को मैप किया गया country_map: {null = Z, XX = null, CHN = चीन, SL = श्रीलंकाई, IND = भारत, KOR = कोरे
सेवा मेरे}
null data_map के लिए महत्वपूर्ण मान: Z
डेटा_मैप शून्य कुंजी निकालने के बाद = {XX = null, CHN = चीन, SL = श्रीलंका, IND = भारत, KOR = कोरिया}
डेटा मैप कीज़: (null, XX, CHN, SL, IND, KOR)
डेटा मैप मान: (Z, null, China, Srilanka, India, Korea)
स्पष्ट संचालन के बाद डेटा मैप, खाली है: सच है

संचालन प्राप्त करें, संचालन करें और सेट करें

जावा में एक मानचित्र छाँटना

जैसा कि एक मानचित्र में कुंजी-मूल्य जोड़े होते हैं, हम नक्शे को कुंजियों या मूल्यों पर सॉर्ट कर सकते हैं।

इस खंड में, हम कुंजियों और मूल्यों दोनों पर एक मानचित्र सॉर्ट करेंगे।

कुंजी के आधार पर छाँटें

चाबियाँ पर एक नक्शा सॉर्ट करने के लिए, हम एक ट्रेमैप का उपयोग कर सकते हैं। ट्रेमैप स्वचालित रूप से कुंजियों को सॉर्ट करता है। नीचे दिए गए जावा प्रोग्राम मैप को ट्रेपैप में परिवर्तित करता है और सॉर्ट की गई कुंजियों को प्रदर्शित करता है।

import java.util.HashMap; import java.util.Map; import java.util.TreeMap; public class Main { public static void main(String() args) { //declare and initialize a map Map country_map = new HashMap(); country_map.put('I', 'India'); country_map.put('C', 'China'); country_map.put('A', 'America'); country_map.put('D', 'Denmark'); country_map.put('X', 'Hongkong'); //print original map System.out.println('Original Unsorted Map: '); display_map(country_map); System.out.println('
Map sorted by Key: '); //convert map to treemap and display it in which keys are auto sorted Map treecountry = new TreeMap(country_map); display_map(treecountry); } public static void display_map(Map map) { //obtain entry iterator and display key value pairs of map for (Map.Entry entry : map.entrySet()) { System.out.println('	' + entry.getKey() + '		' + entry.getValue()); } } }

आउटपुट:

मूल अनसुलझा नक्शा:
एक अमेरिका
C चीन
D डेनमार्क
एक्स हांगकांग
मैं भारत
मानचित्र कुंजी द्वारा छांटा गया:
एक अमेरिका
C चीन
D डेनमार्क
मैं भारत
एक्स हांगकांग

कुंजी के आधार पर छाँटें

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

मूल्य के आधार पर छाँटें

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

एक बार सूची को क्रमबद्ध करने के बाद, लिंक की गई सूची प्रविष्टियों को फिर से नक़्शे पर कॉपी किया जाता है जो हमें क्रमबद्ध नक्शा देता है।

निम्न जावा प्रोग्राम मूल्य के आधार पर एक मानचित्र के छंटाई को दर्शाता है। कार्यक्रम LinkedHashMap का उपयोग करता है जिसे छँटाई समारोह में पारित किया जाता है। सॉर्टिंग फ़ंक्शन में, इसे एक लिंक की गई सूची में बदल दिया जाता है और सॉर्ट किया जाता है। छाँटने के बाद इसे वापस LinkedHashMap में बदल दिया जाता है।

सी # साक्षात्कार प्रश्न और फ्रेशर्स के लिए उत्तर

import java.util.*; public class Main { public static void main(String() args) { //define and initialize a map LinkedHashMap capitals_map = new LinkedHashMap(); capitals_map.put('NEP', 'Kathmandu'); capitals_map.put('IND', 'New Delhi'); capitals_map.put('USA', 'Washington'); capitals_map.put('UK', 'London'); capitals_map.put('AUS', 'Canberra'); //print original map System.out.println('Original unsorted map: '); System.out.println(capitals_map); //call sortMap method Map sorted_Map = sortMap(capitals_map); //print the sorted map System.out.println('
Map sorted on value : '); System.out.println('	Key	Value '); for (Map.Entry entry : sorted_Map.entrySet()) { System.out.println('	' + entry.getKey()+ '	' + entry.getValue()); } } public static LinkedHashMap sortMap(LinkedHashMap linked_map) { //create a linkedlist from LinkedHashMap List capital_List = new LinkedList(linked_map.entrySet()); //sort the LinkedList Collections.sort(capital_List, (o1, o2) -> o1.getValue().compareTo(o2.getValue())); //Create LinkedHashMap from linkedlist and return it LinkedHashMap finalMap = new LinkedHashMap(); for (Map.Entry entry : capital_List) { finalMap.put(entry.getKey(), entry.getValue()); } return finalMap; } }

आउटपुट:

मूल अनसुलझा नक्शा:
{एनईपी = काठमांडू, आईएन = नई दिल्ली, यूएसए = वाशिंगटन, यूके = लंदन, एयूएस = कैनबरा

मानचित्र को मूल्य पर क्रमबद्ध किया गया:
मौलिक मूल्य
कैनबरा से
एनईपी काठमांडू
यूके लंदन
IND नई दिल्ली
यूएसए वाशिंगटन

मूल्य के आधार पर छाँटें

जावा में समवर्ती मानचित्र

एक समवर्ती नक्शा एक इंटरफ़ेस है जो java.util.map इंटरफ़ेस से विरासत में मिला है। समवर्ती मानचित्र इंटरफ़ेस को पहले JDK 1.5 में पेश किया गया था और यह एक मानचित्र प्रदान करता है जो समवर्ती पहुंच को संभालता है।

समवर्ती मैप इंटरफ़ेस java.util.concurrent पैकेज का हिस्सा है।

निम्न जावा प्रोग्राम जावा में समवर्ती मानचित्र प्रदर्शित करता है।

import java.util.concurrent.*; class Main { public static void main(String() args) { //create and initialize concurrentHashMap ConcurrentHashMap m = new ConcurrentHashMap(); m.put(100, 'Red'); m.put(101, 'Green'); m.put(102, 'Blue'); System.out.println('
Initial Concurrent Map : ' + m); //add a key using putIfAbsent method; key=103 is absent so its added m.putIfAbsent(103, 'Purple'); System.out.println('
After adding absent key 103 : ' + m); m.remove(101, 'Green'); // remove key = 101 System.out.println('
Concurrent Map after removing 101:' + m); m.putIfAbsent(101, 'Brown'); // again add key = 101 since its absent System.out.println('
Add absent key 101:' + m); m.replace(101, 'Brown', 'Green'); // replace value for key = 101 with 'Green' System.out.println('
Replace value at key 101:' + m); } } import java.util.concurrent.*; class Main { public static void main(String() args) { //create and initialize concurrentHashMap ConcurrentHashMap m = new ConcurrentHashMap(); m.put(100, 'Red'); m.put(101, 'Green'); m.put(102, 'Blue'); System.out.println('
Initial Concurrent Map : ' + m); //add a key using putIfAbsent method; key=103 is absent so its added m.putIfAbsent(103, 'Purple'); System.out.println('
After adding absent key 103 : ' + m); m.remove(101, 'Green'); // remove key = 101 System.out.println('
Concurrent Map after removing 101:' + m); m.putIfAbsent(101, 'Brown'); // again add key = 101 since its absent System.out.println('
Add absent key 101:' + m); m.replace(101, 'Brown', 'Green'); // replace value for key = 101 with 'Green' System.out.println('
Replace value at key 101:' + m); } }

आउटपुट:

प्रारंभिक समवर्ती नक्शा: {100 = लाल, 101 = हरा, 102 = नीला}
अनुपस्थित कुंजी 103 जोड़ने के बाद: {100 = लाल, 101 = हरा, 102 = नीला, 103 = बैंगनी}
101 हटाने के बाद समवर्ती नक्शा: {100 = लाल, 102 = नीला, 103 = बैंगनी}
अनुपस्थित कुंजी 101 जोड़ें: {100 = लाल, 101 = भूरा, 102 = नीला, 103 = बैंगनी}
मान को कुंजी 101 पर बदलें: {100 = लाल, 101 = हरा, 102 = नीला, 103 = बैंगनी}

जावा में समवर्ती नक्शा

जावा में सिंक्रोनाइज़्ड मैप

एक सिंक्रनाइज़ मैप एक ऐसा मैप है जो थ्रेड-सुरक्षित है और किसी दिए गए मैप द्वारा समर्थित है। जावा में, सिंक्रोनाइज़्ड मैप को java.util.Collections वर्ग के सिंक्रोनाइज़ेशन () पद्धति का उपयोग करके प्राप्त किया जाता है। यह विधि किसी दिए गए नक्शे के लिए एक सिंक्रनाइज़ मैप देता है।

इस लौटे सिंक्रोनाइज़्ड मैप का उपयोग सीरियल एक्सेस प्राप्त करने के लिए बैकिंग मैप को एक्सेस करने के लिए किया जाता है।

सिंक्रोनाइज़ेशन () विधि की सामान्य घोषणा है:

public static Map synchronizedMap(Map m)

जहाँ m => समर्थित मानचित्र है।

जैसा कि पहले ही उल्लेख किया गया है कि यह विधि मैप m के समकालिक दृश्य को लौटाती है

नीचे जावा प्रोग्राम एक सिंक्रनाइज़ मैप का एक उदाहरण है।

import java.util.*; public class Main { public static void main(String() args) { //declare and initialize a map Map int_map = new HashMap(); int_map.put(1, 10); int_map.put(2, 20); int_map.put(3, 30); int_map.put(4, 40); int_map.put(5, 50); //print the map System.out.println('Original (backed) Map: ' + int_map); //obtain synchronized map Map sync_map = Collections.synchronizedMap(int_map); //remove an element from the map int_map.remove(3, 30); //print the altered map System.out.println('
Synchronized map after remove(3, 30):' + sync_map); } }

आउटपुट:

मूल (समर्थित) नक्शा: {१ = १०, २ = २०, ३ = ३०, ४ = ४०, ५ = ५०}
हटाने के बाद सिंक्रोनाइज़्ड मैप (3, 30): {1 = 10, 2 = 20, 4 = 40, 5 = 50}

जावा में सिंक्रोनाइज़्ड मैप

जावा में स्थैतिक मानचित्र

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

जावा में एक स्थिर मानचित्र बनाने और शुरू करने के लिए दो दृष्टिकोण हैं।

(1) एक स्थैतिक चर का उपयोग करना

यहां, हम एक स्थैतिक मानचित्र चर बनाते हैं और घोषणा के साथ इसे तुरंत भेजते हैं।

इस दृष्टिकोण को निम्न जावा प्रोग्राम में प्रदर्शित किया जाता है।

import java.util.*; class Main { //declare a static map variable and initialize it with declaration private static final Map myMap = new HashMap(){ { put(1, 'India'); put(2, 'Portugal'); put(3, 'Germany'); } }; public static void main(String() args) { //print the map System.out.println('Static map using static map variable:'); System.out.println(myMap); } }

आउटपुट:

स्थैतिक मानचित्र चर का उपयोग कर स्थैतिक मानचित्र:
{१ = भारत, २ = पुर्तगाल, ३ = जर्मनी}

स्टैटिक ब्लॉक का उपयोग करना

# 2) स्टेटिक ब्लॉक का उपयोग करना

इसमें हम स्टैटिक मैप वेरिएबल बनाते हैं। फिर हम एक स्टैटिक ब्लॉक बनाते हैं और इस स्टैटिक ब्लॉक के अंदर हम मैप वेरिएबल को इनिशियलाइज़ करते हैं।

नीचे दिया गया कार्यक्रम यह प्रदर्शित करता है।

import java.util.*; class Main { // Declare the static map private static Map map; // declare a static block and initialize static map static { map = new HashMap(); map.put(1, 'Red'); map.put(2, 'Green'); map.put(3, 'Blue'); } public static void main(String() args) { System.out.println('Static Map using static block:'); System.out.println(map); } }

आउटपुट:

स्थैतिक ब्लॉक का उपयोग करके स्थैतिक मानचित्र:
{१ = लाल, २ = हरा, ३ = नीला}

स्टैटिक ब्लॉक का उपयोग करना

मानचित्र में सूची का रूपांतरण

इस खंड में, हम सूची को मानचित्र में बदलने के तरीकों पर चर्चा करेंगे।

दो तरीकों में शामिल हैं:

पारंपरिक विधि

पारंपरिक विधि में, प्रत्येक सूची तत्व को प्रत्येक लूप का उपयोग करके नक्शे में कॉपी किया जाता है।

यह कार्यान्वयन नीचे दिखाया गया है:

import java.util.*; public class Main { public static void main(String() args) { //declare and initialize a list List colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('Brown'); colorsList.add('White'); System.out.println('The given list: ' + colorsList); //declare a map Map map = new HashMap(); //initial Id(key) int i=1; //assign each list element to the map for (String color : colorsList) { map.put(i, color); i++; } //print the map System.out.println('Map generated from List:' + map); } }

आउटपुट:

दी गई सूची: (लाल, हरा, नीला, भूरा, सफेद)
मानचित्र सूची से उत्पन्न: {1 = लाल, 2 = हरा, 3 = नीला, 4 = भूरा, 5 = सफेद}

पारंपरिक विधि

जावा 8 में मानचित्र की सूची

हम Java 8 मेथड कलेक्टरों .mapOf () का भी उपयोग कर सकते हैं जो दी गई सूची को मानचित्र में बदल देगा।

नीचे दिया गया कार्यक्रम यह प्रदर्शित करता है।

import java.util.ArrayList; import java.util.LinkedHashMap; import java.util.List; import java.util.stream.Collectors; // class for list class Subject { //sub_id => map key private Integer sub_id; // sub_name => map value private String sub_name; // Subject constructor public Subject(Integer sub_id, String sub_name) { // initialize sub_id and sub_name this.sub_id = sub_id; this.sub_name = sub_name; } // return sub_id public Integer getSub_Id() { return sub_id; } // return sub_name public String getSub_Name() { return sub_name; } } public class Main { public static void main(String() args) { // create a list and add values to the list List sub_list = new ArrayList(); sub_list.add(new Subject(1, 'Abacus')); sub_list.add(new Subject(2, 'Maths')); sub_list.add(new Subject(3, 'Physics')); sub_list.add(new Subject(3, 'Chemistry')); //use Java 8 Collectors.toMap() method to create a map and assign list elements to it LinkedHashMap sub_map = sub_list.stream() .collect( Collectors.toMap(Subject::getSub_Id, Subject::getSub_Name,(x, y) -> x + ', ' + y, LinkedHashMap::new)); //print the map System.out.println('Map obtained from list : ' + sub_map); } }

आउटपुट:

सूची से प्राप्त मानचित्र: {1 = अबेकस, 2 = गणित, 3 = भौतिकी, रसायन विज्ञान}

जावा 8 में मानचित्र की सूची

इस कार्यक्रम में, हमारे पास एक वर्ग विषय है जो एक सूची वर्ग के रूप में कार्य करता है। क्लास सब्जेक्ट में दो फील्ड होते हैं यानी सब_आईडी और सब_नाम। हमारे पास कक्षा से फ़ील्ड मान पढ़ने के तरीके हैं। मुख्य फ़ंक्शन में, हम इस वर्ग की वस्तुओं को बनाते हैं और एक सूची बनाते हैं।

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

जावा में स्ट्रिंग को मैप कन्वर्ट करें

एक मानचित्र संग्रह को दो दृष्टिकोणों का उपयोग करके स्ट्रिंग में परिवर्तित किया जा सकता है:

StringBuilder का उपयोग करना

यहाँ हम एक StringBuilder ऑब्जेक्ट बनाते हैं और फिर StringBuilder ऑब्जेक्ट में मैप के मुख्य-वैल्यू जोड़े को कॉपी करते हैं। फिर हम स्ट्रिंग स्ट्रिंग ऑब्जेक्ट को स्ट्रिंग में परिवर्तित करते हैं।

नीचे दिया गया प्रोग्राम जावा कोड को मैप को स्ट्रिंग में बदलने के लिए दिखाता है।

import java.util.*; import java.util.stream.Collectors; public class Main { public static void main(String() args) { //create and initialize a map Map numberNames = new HashMap(); numberNames.put(10, 'Ten'); numberNames.put(20, 'Twenty'); numberNames.put(30, 'Thirty'); numberNames.put(40, 'Forty'); //print the given map System.out.println('The given map: ' + numberNames); //create a StringBuilder object to store string StringBuilder map_String = new StringBuilder('{'); //append key-value pair of map to StringBuilder object for (Integer key : numberNames.keySet()) { map_String.append(key + '=' + numberNames.get(key) + ', '); } map_String.delete(map_String.length()-2, map_String.length()).append('}'); //print the string from StringBuilder System.out.println('
The string representation of map:'); System.out.println(map_String.toString()); } }

आउटपुट:

दिए गए नक्शे: {20 = बीस, 40 = चालीस, 10 = दस, 30 = तीस}
नक्शे का स्ट्रिंग प्रतिनिधित्व:
{२० = बीस, ४० = चालीस, १० = दस, ३० = तीस}

StringBuilder का उपयोग करना

जावा 8 स्ट्रीम का उपयोग करना

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

नीचे दिया गया कार्यक्रम धाराओं का उपयोग करके मानचित्र के एक स्ट्रिंग में रूपांतरण को दर्शाता है।

import java.util.*; import java.util.stream.Collectors; public class Main{ public static void main(String() args) { //create and initialize a map Map numberNames = new HashMap(); numberNames.put(10, 'Ten'); numberNames.put(20, 'Twenty'); numberNames.put(30, 'Thirty'); numberNames.put(40, 'Forty'); //print the given map System.out.println('The given map: ' + numberNames); String map_String = numberNames.keySet().stream() .map(key -> key + '=' + numberNames.get(key)) .collect(Collectors.joining(', ', '{', '}')); //print the string System.out.println('
The string representation of map:'); System.out.println(map_String); } }

आउटपुट:

जावा 8 स्ट्रीम का उपयोग करना

जावा में सूची को मैप में बदलें

एक मानचित्र में कुंजियाँ और मूल्य होते हैं जबकि एक सूची व्यक्तिगत तत्वों का एक क्रम है। मानचित्र को सूची में परिवर्तित करते समय, हम आम तौर पर कुंजियों को सूची और मानों की सूची में बदल देते हैं।

निम्न जावा प्रोग्राम इस रूपांतरण को दिखाता है।

import java.util.*; public class Main { public static void main(String() args) { //declare a map and initialize it Map color_map = new HashMap(); color_map.put(10, 'red'); color_map.put(20, 'green'); color_map.put(30, 'blue'); color_map.put(40, 'cyan'); color_map.put(50, 'magenta'); //print the list of keys using map.keySet() method System.out.println('List of keys from the given map:'); List key_list = new ArrayList(color_map.keySet()); System.out.println(key_list); //print the list of values using map.values() method System.out.println('
List of values from the given map:'); List val_list = new ArrayList(color_map.values()); System.out.println(val_list); } }

आउटपुट:

दिए गए नक्शे से कुंजियों की सूची:
(५०, २०, ४०, १०, ३०)
दिए गए नक्शे से मूल्यों की सूची:
(मैजेंटा, हरा, सियान, लाल, नीला)

जावा में सूचीबद्ध करने के लिए मानचित्र में परिवर्तित करें

शब्दकोश बनाम। जावा में नक्शा

जावा में शब्दकोश और मानचित्र के बीच कुछ प्रमुख अंतरों पर चर्चा करते हैं।

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

बार बार पूछे जाने वाले प्रश्न

क्यू # 1) हम जावा में एक मैप इंटरफ़ेस का उपयोग क्यों करते हैं?

विंडोज़ में eps फाइलें कैसे खोलें

उत्तर: मानचित्र जावा में एक इंटरफ़ेस है जो डेटा को कुंजी-मूल्य जोड़े के रूप में संग्रहीत करने वाली कक्षाओं द्वारा कार्यान्वित किया जाता है। मानचित्र इंटरफ़ेस संचालन / विधियाँ प्रदान करता है, जिन्हें कुंजी-मूल्य जोड़े जैसे प्रविष्टि, अद्यतन, विलोपन आदि पर किया जा सकता है।

क्यू # 2)जावा में MAP का क्या अर्थ है?

उत्तर: जावा में एक मानचित्र एक विशिष्ट मूल्य के साथ एक कुंजी के मानचित्रण का प्रतिनिधित्व करता है। जावा मैप इन की-वैल्यू जोड़े को मैप में स्टोर करता है। हम मानचित्र में कुंजी का उपयोग करके कुंजी के साथ जुड़े मूल्य को देख और पुनः प्राप्त कर सकते हैं।

Java में एक इंटरफ़ेस का उपयोग करके एक नक्शा लागू किया गया है जो संग्रह इंटरफ़ेस का हिस्सा नहीं है। लेकिन नक्शा एक संग्रह है।

क्यू # 3)MAP क्या है?

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

क्यू # 4)क्या मानचित्र एक संग्रह है?

उत्तर: हालाँकि मानचित्र को सामान्य रूप से संग्रह के रूप में देखा जाता है, यह संग्रह इंटरफ़ेस लागू नहीं करता है। मानचित्र के कार्यान्वयन में से कुछ, जैसे ट्रेम्पैप अशक्त मूल्यों या कुंजियों का समर्थन नहीं करता है।

क्यू # 5)सेट और मैप में क्या अंतर है?

उत्तर: सेट केवल कुंजियों का एक संग्रह है, जबकि मानचित्र कुंजी-मूल्य जोड़े का एक संग्रह है। जबकि सेट शून्य मानों की अनुमति नहीं देता है, लेकिन मानचित्र कार्यान्वयन में से कुछ शून्य मानों की अनुमति देते हैं।

सेट डुप्लिकेट कुंजियों की अनुमति नहीं देता है। नक्शा डुप्लिकेट मानों की अनुमति दे सकता है, लेकिन कुंजी अद्वितीय होनी चाहिए। सेट का उपयोग आमतौर पर तब किया जाता है जब हम अनूठे तत्वों के संग्रह को संग्रहित करना चाहते हैं। मानचित्र का उपयोग तब किया जा सकता है जब हमें कुंजी-मूल्य जोड़े के रूप में डेटा संग्रहीत करने की आवश्यकता होती है।

निष्कर्ष

इस ट्यूटोरियल में, हमने मैप इंटरफेस की मूल बातें पर चर्चा की है। हमने जावा में मानचित्र इंटरफ़ेस से संबंधित विभिन्न तरीकों और अन्य सभी विवरणों को भी देखा है। हमें पता चला कि ट्रेम्पैप, हैशमैप, आदि सहित मानचित्र इंटरफेस के विभिन्न कार्यान्वयन हैं।

हमारे आगामी ट्यूटोरियल में, हम इस नक्शे के कार्यान्वयन पर अधिक विस्तार से चर्चा करेंगे।

=> स्क्रैच से जावा सीखने के लिए यहां जाएं।

कार्यान्वयन और उदाहरण के साथ जावा मैप इंटरफ़ेस ट्यूटोरियल

जावा में मैप्स

जावा में एक नक्शा बनाएँ

जावा में एक मैप को इनिशियलाइज़ करें

(1) संग्रह का उपयोग करना

# 2) जावा 8 का उपयोग करना

# 3) मैप इंटरफेस के पुट विधि का उपयोग करना

# 4) डबल ब्रेस इनिशियलाइज़ेशन का उपयोग करना

जावा में मानचित्र पर Iterate और मानचित्र मुद्रित करें

एंट्री इटरेटर का उपयोग करना

प्रत्येक लूप के लिए एक प्रविष्टि का उपयोग करना

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

जावा मानचित्र कार्यान्वयन

जावा में एक मानचित्र छाँटना

कुंजी के आधार पर छाँटें

मूल्य के आधार पर छाँटें

जावा में समवर्ती मानचित्र

जावा में सिंक्रोनाइज़्ड मैप

जावा में स्थैतिक मानचित्र

(1) एक स्थैतिक चर का उपयोग करना

# 2) स्टेटिक ब्लॉक का उपयोग करना

मानचित्र में सूची का रूपांतरण

पारंपरिक विधि

जावा 8 में मानचित्र की सूची

जावा में स्ट्रिंग को मैप कन्वर्ट करें

StringBuilder का उपयोग करना

जावा 8 स्ट्रीम का उपयोग करना

जावा में सूची को मैप में बदलें

शब्दकोश बनाम। जावा में नक्शा

बार बार पूछे जाने वाले प्रश्न

निष्कर्ष

अनुशंसित पाठ