जावा में ट्रीमैप

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

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

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

लाल-काला पेड़

आपने शायद देखा है कि, हुड के नीचे, ट्रीमैप लाल-काले पेड़ नामक डेटा संरचना का उपयोग करता है। इस संरचना में डेटा संग्रहीत करना ठीक वही है जो डेटा ऑर्डरिंग प्रदान करता है। तो यह कैसा पेड़ है? आइए इसका पता लगाएं! कल्पना कीजिए कि आपको संख्या-स्ट्रिंग जोड़े को स्टोर करने की आवश्यकता है। संख्या 16, 20, 52, 55, 61, 65, 71, 76, 81, 85, 90, 93 और 101 कुंजियाँ होंगी। यदि आप एक पारंपरिक सूची में डेटा संग्रहीत करते हैं और आपको 101 कुंजी के साथ तत्व खोजने की आवश्यकता है, तो आपको इसे खोजने के लिए सभी 13 तत्वों के माध्यम से कदम उठाने की आवश्यकता होगी। 13 तत्वों के लिए, यह कोई बड़ी बात नहीं है, लेकिन जब हम एक मिलियन के साथ काम करते हैं, तो हमें बड़ी समस्याएँ होंगी। इन समस्याओं को हल करने के लिए, प्रोग्रामर थोड़ी अधिक जटिल डेटा संरचनाओं का उपयोग करते हैं। यहीं से मंच में प्रवेश करता है लाल-काला पेड़!किसी तत्व की खोज पेड़ की जड़ से शुरू होती है, जो हमारे मामले में 61 है। फिर हम नोड मानों की तुलना उस मान से करते हैं जिसकी हम तलाश कर रहे हैं। यदि हमारा मूल्य कम है, तो हम बाईं ओर चले जाते हैं; यदि यह बड़ा है, तो हम दाईं ओर जाते हैं। यह प्रक्रिया तब तक दोहराई जाती है जब तक हमें वांछित मान नहीं मिल जाता है या एक ऐसे तत्व का सामना नहीं होता है जिसका मान शून्य (पेड़ का एक पत्ता) है। पेड़ को नेविगेट करने और संतुलित करने के लिए लाल और काले रंग का उपयोग किया जाता है। ऐसे नियम हैं जिन्हें लाल-काले पेड़ का निर्माण करते समय हमेशा देखा जाना चाहिए:

• जड़ काली होनी चाहिए।
• पेड़ की पत्तियाँ काली होनी चाहिए।
• एक लाल नोड में दो ब्लैक चाइल्ड नोड होने चाहिए।
• एक ब्लैक नोड में किसी भी रंग का चाइल्ड नोड हो सकता है।
• एक नोड से उसके पत्तों तक के पथ में समान संख्या में काले नोड होने चाहिए।
• पत्तियों में नए नोड जोड़े जाते हैं।

यदि आप नियम 3, 4 और 5 पर एक साथ विचार करते हैं, तो आप समझ सकते हैं कि कैसे नोड रंग हमें पेड़ को अधिक तेज़ी से नेविगेट करने देता है: काले नोड्स के माध्यम से पथ हमेशा लाल नोड्स के माध्यम से एक से छोटा होता है। तदनुसार, पेड़ का कुल आकार काले नोड्स की संख्या से निर्धारित होता है, जिसे "ब्लैक हाइट" कहा जाता है। लाल-काले पेड़ की डेटा संरचना विभिन्न प्रोग्रामिंग भाषाओं में कार्यान्वित की जाती है। इंटरनेट पर बहुत सारे जावा कार्यान्वयन हैं, इसलिए हम यहां रुके नहीं रहेंगे। इसके बजाय, ट्रीमैप की कार्यक्षमता को जानना जारी रखें।

SortedMap और NavigableMap इंटरफ़ेस से आने वाली विधियाँ

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

• firstKey () : मानचित्र में पहले तत्व की कुंजी लौटाता है
• lastKey () : अंतिम तत्व की कुंजी लौटाता है
• हेडमैप (के अंत) : एक नक्शा देता है जिसमें वर्तमान मानचित्र के सभी तत्व शामिल होते हैं, शुरुआत से लेकर मुख्य अंत तक तत्व
• टेलमैप (के स्टार्ट) : एक नक्शा देता है जिसमें वर्तमान मानचित्र के सभी तत्व शामिल होते हैं, प्रारंभ तत्व से अंत तक
• subMap(K start, K ​​end) : एक नक्शा लौटाता है जिसमें वर्तमान मानचित्र के सभी तत्व शामिल होते हैं, प्रारंभ तत्व से कुंजी अंत वाले तत्व तक।

NavigableMap एक इंटरफ़ेस है जो SortedMap का विस्तार करता है और मानचित्र के तत्वों के बीच नेविगेट करने के तरीके जोड़ता है:

• firstEntry() : पहला की-वैल्यू पेयर लौटाता है
• lastEntry() : अंतिम की-वैल्यू पेयर लौटाता है
• पोलफर्स्टएंट्री () : पहली जोड़ी को लौटाता है और हटाता है
• पोललास्टएंट्री () : अंतिम जोड़ी को लौटाता है और हटाता है
• सीलिंगके (के ओबीजे) : सबसे छोटी कुंजी के लौटाता है जो कि कुंजी ओबीजे से अधिक या उसके बराबर है। अगर ऐसी कोई कुंजी नहीं है, तो शून्य वापस आती है
• मंजिलकी (के ओबीजे) : सबसे बड़ी कुंजी के लौटाता है जो कुंजी ओबीजे से कम या उसके बराबर है। अगर ऐसी कोई कुंजी नहीं है, तो शून्य वापस आती है
• lowerKey(K obj) : सबसे बड़ी कुंजी k लौटाता है जो कुंजी obj से कम है। अगर ऐसी कोई कुंजी नहीं है, तो शून्य वापस आती है
• HighKey(K obj) : सबसे छोटी कुंजी k लौटाता है जो कुंजी obj से बड़ी होती है। अगर ऐसी कोई कुंजी नहीं है, तो शून्य वापस आती है
• सीलिंगएन्ट्री (के ओबीजे) : सीलिंगकी (के ओबीजे) विधि के समान, केवल एक कुंजी-मूल्य जोड़ी (या शून्य) देता है
• फ्लोरएन्ट्री (के ओबीजे) : फ्लोरकी (के ओबीजे) विधि के समान, केवल एक कुंजी-मूल्य जोड़ी (या शून्य) देता है
• लोअरएन्ट्री (के ओबीजे) : लोअरकी (के ओबीजे) विधि के समान, केवल एक कुंजी-मूल्य जोड़ी (या शून्य) देता है
• हायरएंट्री (के ओबीजे) : हायरके (के ओबीजे) विधि के समान, केवल एक कुंजी-मूल्य जोड़ी (या शून्य) देता है
• अवरोहीकीसेट () : एक नेविगेबलसेट लौटाता है जिसमें रिवर्स ऑर्डर में सॉर्ट की गई सभी कुंजियाँ होती हैं
• अवरोही मैप () : रिवर्स ऑर्डर में सॉर्ट किए गए सभी जोड़े वाले एक नेविगेबल मैप लौटाता है
• navigableKeySet() : एक NavigableSet ऑब्जेक्ट लौटाता है जिसमें सभी कुंजियाँ उस क्रम में होती हैं जिसमें वे संग्रहीत होते हैं
• हेडमैप (K अपरबाउंड, बूलियन incl) : एक मैप लौटाता है जिसमें शुरुआत से लेकर अपरबाउंड एलिमेंट तक के जोड़े होते हैं। incl पैरामीटर इंगित करता है कि लौटाए गए मानचित्र में ऊपरी बाउंड तत्व को शामिल करना है या नहीं
• टेलमैप (K लोअरबाउंड, बूलियन incl) : पिछली विधि के समान कार्यक्षमता, लोअरबाउंड से अंत तक केवल जोड़े लौटाता है
• सबमैप (K लोअरबाउंड, बूलियन लोइनक्ल, के अपरबाउंड, बूलियन हाईइनक्ल) : पिछले तरीकों की तरह, लोअरबाउंड से अपरबाउंड तक जोड़े लौटाता है; तर्क lowIncl और highIncl इंगित करते हैं कि नए मानचित्र में सीमा तत्वों को शामिल करना है या नहीं।

सामान्य कंस्ट्रक्टरों के अलावा, ट्रीमैप में एक और कंस्ट्रक्टर है जो एक तुलनित्र का उदाहरण स्वीकार करता है। यह तुलनित्र उस क्रम के लिए ज़िम्मेदार है जिसमें तत्व संग्रहीत होते हैं।

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

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

• हमें प्रत्येक व्यक्ति के लिए छापों की संख्या पर नज़र रखने की आवश्यकता है
• अवयस्कों को विज्ञापन प्रदर्शित करने का एल्गोरिद्म अलग है।

चलिए एक व्यक्ति वर्ग बनाते हैं, जो प्रत्येक व्यक्ति के बारे में सभी प्रासंगिक जानकारी संग्रहीत करेगा:

public class Person {
   public String firstName;
   public String lastName;
   public int age;

   public Person(String firstName, String lastName, int age) {
       this.firstName = firstName;
       this.lastName = lastName;
       this.age = age;
   }
}

हम मुख्य वर्ग में तर्क लागू करते हैं :

import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;

public class Main {
   public static void main(String[] args) {
      TreeMap<Person, Integer> map = new TreeMap<>(Comparator.comparingInt(o -> o.age));
      map.put(new Person("John", "Smith", 17), 0);
      map.put(new Person("Ivan", "Petrenko", 65), 0);
      map.put(new Person("Pedro", "Escobar", 32), 0);
      map.put(new Person("Shirley", "Hatfield", 14), 0);
      map.put(new Person("Abby", "Parsons", 19), 0);

      Person firstAdultPerson = map.navigableKeySet().stream().filter(person -> person.age>18).findFirst().get();

       Map<Person, Integer> youngPeopleMap = map.headMap(firstAdultPerson, false);
       Map<Person, Integer> adultPeopleMap = map.tailMap(firstAdultPerson, true);
       showAdvertisementToYoung(youngPeopleMap);
       showAdvertisementToAdult(adultPeopleMap);
   }

   public static void showAdvertisementToYoung(Map map) {}
   public static void showAdvertisementToAdult(Map map) {}
}

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