जावा हाशप मर्ज () विधि निर्दिष्ट कुंजी / मान मैपिंग को हैशमैप में सम्मिलित करता है यदि निर्दिष्ट कुंजी पहले से मौजूद नहीं है।
यदि निर्दिष्ट कुंजी पहले से ही एक मूल्य के साथ जुड़ा हुआ है, तो विधि निर्दिष्ट फ़ंक्शन के परिणाम के साथ पुराने मूल्य को बदल देती है।
merge()विधि का सिंटैक्स है:
hashmap.merge(key, value, remappingFunction)
यहाँ, हैशमप HashMapवर्ग की एक वस्तु है ।
मर्ज () पैरामीटर
merge()विधि 3 पैरामीटर लेता है:
- कुंजी - कुंजी जिसके साथ निर्दिष्ट मूल्य जुड़ा होना है
- मूल्य - मूल्य कुंजी के साथ जुड़ा होना चाहिए, यदि कुंजी पहले से ही किसी भी मूल्य के साथ जुड़ा हुआ है
- यदि कोई कुंजी पहले से किसी मान से संबद्ध है, तो रीमैपिंगफ़ंक्शन - कुंजी से संबद्ध होने का परिणाम है
मर्ज () रिटर्न मान
- कुंजी से जुड़ा नया मान लौटाता है
nullयदि कोई कुंजी के साथ जुड़े मूल्य नहीं देता है
नोट : यदि रीमैपिंगफंक्शन का परिणाम है null, तो निर्दिष्ट कुंजी के लिए मैपिंग हटा दी जाती है।
उदाहरण 1: नई प्रविष्टि सम्मिलित करने के लिए हाशप मर्ज ()
import java.util.HashMap; class Main ( public static void main(String() args) ( // create an HashMap HashMap prices = new HashMap(); // insert entries to the HashMap prices.put("Shoes", 200); prices.put("Bag", 300); prices.put("Pant", 150); System.out.println("HashMap: " + prices); int returnedValue = prices.merge("Shirt", 100, (oldValue, newValue) -> oldValue + newValue); System.out.println("Price of Shirt: " + returnedValue); // print updated HashMap System.out.println("Updated HashMap: " + prices); ) )
आउटपुट
HashMap: (पंत = 150, बैग = 300, जूते = 200) शर्ट की कीमत: 100 अपडेट किए गए हैशमैप: (पंत = 150, शर्ट = 100, बैग = 300, जूते = 200)
उपरोक्त उदाहरण में, हमने एक हैशमैप नाम की कीमतें बनाई हैं। अभिव्यक्ति पर ध्यान दें,
prices.merge("Shirt", 100, (oldValue, newValue) -> oldValue + newValue)
यहाँ, हमने लैम्ब्डा अभिव्यक्ति का उपयोग किया है, (oldValue, newValue) -> oldValue + newValue)रीमैपिंग फ़ंक्शन के रूप में। लैम्ब्डा अभिव्यक्ति के बारे में अधिक जानने के लिए, जावा लैम्बडा एक्सप्रेशंस पर जाएँ।
चूंकि कुंजी शर्ट कीमतों में मौजूद नहीं है, इसलिए merge()विधि मैपिंग सम्मिलित करती है Shirt=100। और, रीमैपिंग फ़ंक्शन के परिणाम को अनदेखा किया जाता है।
उदाहरण 2: HashMap मर्ज () डुप्लिकेट कुंजी के साथ प्रविष्टि सम्मिलित करने के लिए
import java.util.HashMap; class Main ( public static void main(String() args) ( // create an HashMap HashMap countries = new HashMap(); // insert entries to the HashMap countries.put("Washington", "America"); countries.put("Canberra", "Australia"); countries.put("Madrid", "Spain"); System.out.println("HashMap: " + countries); // merge mapping for key Washington String returnedValue = countries.merge("Washington", "USA", (oldValue, newValue) -> oldValue + "/" + newValue); System.out.println("Washington: " + returnedValue); // print updated HashMap System.out.println("Updated HashMap: " + countries); ) )
आउटपुट
HashMap: (मैड्रिड = स्पेन, कैनबरा = ऑस्ट्रेलिया, वॉशिंगटन = अमेरिका) वाशिंगटन: अमेरिका / यूएसए अपडेट किया गया हैशमैप: (मैड्रिड = स्पेन, कैनबरा = ऑस्ट्रेलिया, वाशिंगटन = अमेरिका / यूएसए),
उपरोक्त उदाहरण में, हमने देशों के नाम से एक हैशमैप बनाया है। अभिव्यक्ति पर ध्यान दें,
countries.merge("Washington", "USA", (oldValue, newValue) -> oldValue + "/" + newValue)
यहाँ, हमने लैम्ब्डा अभिव्यक्ति का उपयोग किया है, (oldValue, newValue) -> oldValue + "/" + newValue)रीमैपिंग फ़ंक्शन के रूप में।
चूंकि प्रमुख वाशिंगटन पहले से ही देशों में मौजूद है, इसलिए पुराने मूल्य को रीमैपिंग फ़ंक्शन द्वारा लौटाए गए मूल्य से बदल दिया जाता है। इसलिए, वाशिंगटन के लिए मानचित्रण में मूल्य अमेरिका / यूएसए शामिल हैं।
उदाहरण 3: HashMap मर्ज () दो HashMaps को मर्ज करने के लिए
import java.util.HashMap; class Main ( public static void main(String() args) ( // create an HashMap HashMap prices1 = new HashMap(); // insert entries to the HashMap prices1.put("Pant", 230); prices1.put("Shoes", 350); System.out.println("HashMap 1: " + prices1); // create another hashmap HashMap prices2 = new HashMap(); //insert entries to the HashMap prices2.put("Shirt", 150); prices2.put("Shoes", 320); System.out.println("HashMap 2: " + prices2); // forEach() access each entries of prices2 // merge() inserts each entry from prices2 to prices1 prices2.forEach((key, value) -> prices1.merge(key, value, (oldValue, newValue) -> ( // return the smaller value if (oldValue < newValue) ( return oldValue; ) else ( return newValue; ) ))); System.out.println("Merged HashMap: " + prices1); ) )
आउटपुट
HashMap 1: (Pant = 230, जूते = 350) HashMap 2: (शर्ट = 150, जूते = 320) मर्ज किए गए HashMap: (Pant = 230, शर्ट = 150, जूते = 320)
उपरोक्त उदाहरण में, हमने price1 और price2 नाम के दो हैशमैप बनाए हैं। कोड को नोटिस करें,
prices2.forEach((key, value) -> prices1.merge(key, value, (oldValue, newValue) -> ( if (oldValue < newValue) ( return oldValue; ) else ( return newValue; ) )));
यहाँ, HashMap forEach () विधि hashmap price2 के प्रत्येक प्रविष्टि तक पहुँचती है और इसे hashmap price1 में विलय कर देती है। हमने दो लंबोर्ग भावों का उपयोग किया है:
- (कुंजी, मूल्य) -> price.merge (…) - यह price1 के प्रत्येक प्रविष्टि तक पहुँचता है और इसे
merge()विधि में भेजता है । - (oldValue, newValue) -> (…) - यह एक रीमैपिंग फ़ंक्शन है। यह दो मूल्यों की तुलना करता है और छोटे मूल्य को लौटाता है।
चूंकि मुख्य शूज़ दोनों हैशमैप में मौजूद होते हैं, शूज़ के मूल्य को रीमैपिंग फ़ंक्शन के परिणाम से बदल दिया जाता है।
Java HashMap मर्ज () बनाम सभी रखें
हम putAll()दो हैशमैप को मर्ज करने की विधि का भी उपयोग कर सकते हैं । हालाँकि, यदि कोई कुंजी दोनों हैशमैप में मौजूद है, तो पुराने मान को नए मान से बदल दिया जाता है।
विधि के विपरीत merge(), putAll()विधि रीमैपिंग फ़ंक्शन प्रदान नहीं करती है। इसलिए, हम यह तय नहीं कर सकते कि डुप्लिकेट कुंजियों के लिए क्या मूल्य संग्रहीत किया जाए।
putAll()विधि के बारे में अधिक जानने के लिए , Java HashMap putAll () पर जाएँ।
