जावा मध्ये TreeMap

जर तुम्ही हा लेख वाचत असाल, तर तुम्ही बहुधा नकाशा इंटरफेसशी परिचित असाल आणि ते कुठे लागू केले जाऊ शकते. नाही तर इथे या . आज आपण Java TreeMap च्या अंमलबजावणीच्या वैशिष्ट्यांबद्दल बोलू, आणि अधिक विशेषतः, ते HashMap पेक्षा कसे वेगळे आहे आणि ते योग्यरित्या कसे वापरावे याबद्दल बोलू.

TreeMap, HashMap आणि LinkedHashMap ची तुलना करणे

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

लाल-काळे झाड

तुमच्या लक्षात आले असेल की, हूडच्या खाली, ट्रीमॅप रेड-ब्लॅक ट्री नावाची डेटा रचना वापरते. या संरचनेत डेटा संचयित करणे हे डेटा क्रम प्रदान करते. मग हे कोणत्या प्रकारचे झाड आहे? चला ते बाहेर काढूया! कल्पना करा की तुम्हाला संख्या-स्ट्रिंग जोड्या संग्रहित करणे आवश्यक आहे. संख्या 16, 20, 52, 55, 61, 65, 71, 76, 81, 85, 90, 93, आणि 101 की असतील. जर तुम्ही पारंपारिक सूचीमध्ये डेटा संग्रहित केला आणि तुम्हाला 101 की सह घटक शोधण्याची आवश्यकता असेल, तर तुम्हाला ते शोधण्यासाठी सर्व 13 घटकांमधून जावे लागेल. 13 घटकांसाठी, ही काही मोठी गोष्ट नाही, परंतु दशलक्षांसह काम करताना, आम्हाला मोठ्या समस्या असतील. या समस्यांचे निराकरण करण्यासाठी, प्रोग्रामर किंचित अधिक जटिल डेटा संरचना वापरतात. इथेच रंगमंचावर लाल-काळ्या झाडाचा प्रवेश!घटकाचा शोध झाडाच्या मुळापासून सुरू होतो, जे आमच्या बाबतीत 61 आहे. मग आम्ही नोड मूल्यांची तुलना आम्ही शोधत असलेल्या मूल्याशी करतो. जर आपली किंमत कमी असेल तर आपण डावीकडे जातो; जर ते मोठे असेल तर आपण उजवीकडे जाऊ. ही प्रक्रिया जोपर्यंत आम्हाला इच्छित मूल्य सापडत नाही किंवा ज्याचे मूल्य शून्य आहे (झाडाचे एक पान) आढळत नाही तोपर्यंत पुनरावृत्ती होते. लाल आणि काळ्या रंगांचा वापर झाडावर नेव्हिगेट करणे आणि संतुलन साधण्यासाठी केला जातो. लाल-काळे झाड बांधताना नेहमी पाळले पाहिजेत असे नियम आहेत:

• रूट काळा असणे आवश्यक आहे.
• झाडाची पाने काळी असावीत.
• लाल नोडमध्ये दोन काळ्या चाइल्ड नोड्स असणे आवश्यक आहे.
• काळ्या नोडमध्ये कोणत्याही रंगाचे चाइल्ड नोड असू शकतात.
• नोडपासून त्याच्या पानापर्यंतच्या मार्गामध्ये काळ्या नोड्सची समान संख्या असणे आवश्यक आहे.
• पानांमध्ये नवीन नोड जोडले जातात.

तुम्ही नियम 3, 4 आणि 5 एकत्र विचारात घेतल्यास, नोडचा रंग आम्हाला झाडावर अधिक वेगाने नेव्हिगेट कसा करू देतो हे तुम्ही समजू शकता: काळ्या नोड्समधून जाणारा मार्ग नेहमी लाल नोड्समधून एकापेक्षा लहान असतो. त्यानुसार, झाडाचा एकूण आकार काळ्या नोड्सच्या संख्येनुसार निर्धारित केला जातो, ज्याला "काळी उंची" म्हणतात. रेड-ब्लॅक ट्री डेटा स्ट्रक्चर विविध प्रोग्रामिंग भाषांमध्ये लागू केले जाते. इंटरनेटवर बरीच Java अंमलबजावणी आहेत, म्हणून आम्ही येथे रेंगाळणार नाही. त्याऐवजी, ट्रीमॅपची कार्यक्षमता जाणून घेणे सुरू ठेवूया.

सॉर्टेडमॅप आणि नेव्हिगेबल मॅप इंटरफेसमधून आलेल्या पद्धती

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

• firstKey() : नकाशातील पहिल्या घटकाची की परत करते
• lastKey() : शेवटच्या घटकाची की परत करते
• headMap(K end) : एक नकाशा परत करतो ज्यामध्ये वर्तमान नकाशाचे सर्व घटक असतात, सुरवातीपासून ते घटकापर्यंत की शेवटी
• tailMap(K start) : एक नकाशा परत करतो ज्यात सध्याच्या नकाशाचे सर्व घटक आहेत, प्रारंभ घटकापासून ते शेवटपर्यंत
• subMap(K start, K ​​end) : एक नकाशा मिळवतो ज्यामध्ये वर्तमान नकाशाचे सर्व घटक असतात, प्रारंभ घटकापासून ते की शेवटी असलेल्या घटकापर्यंत.

NavigableMap हा एक इंटरफेस आहे जो सॉर्टेडमॅपचा विस्तार करतो आणि नकाशाच्या घटकांमध्ये नेव्हिगेट करण्यासाठी पद्धती जोडतो:

• firstEntry() : प्रथम की-व्हॅल्यू जोडी परत करते
• lastEntry() : शेवटची की-व्हॅल्यू जोडी परत करते
• pollFirstEntry() : पहिली जोडी परत करते आणि हटवते
• pollLastEntry() : शेवटची जोडी परत करते आणि हटवते
• ceilingKey(K obj) : की obj पेक्षा मोठी किंवा समान असलेली सर्वात लहान की k मिळवते. अशी कोणतीही की नसल्यास, शून्य परत करते
• floorKey(K obj) : की obj पेक्षा कमी किंवा समान असलेली सर्वात मोठी की k मिळवते. अशी कोणतीही की नसल्यास, शून्य परत करते
• LowerKey(K obj) : की obj पेक्षा कमी असलेली सर्वात मोठी की k मिळवते. अशी कोणतीही की नसल्यास, शून्य परत करते
• highKey(K obj) : की obj पेक्षा मोठी असलेली सर्वात लहान की k मिळवते. अशी कोणतीही की नसल्यास, शून्य परत करते
• ceilingEntry(K obj) : ceilingKey(K obj) पद्धती प्रमाणेच, फक्त एक की-व्हॅल्यू जोडी (किंवा शून्य) मिळवते
• floorEntry(K obj) : floorKey(K obj) पद्धतीप्रमाणेच, फक्त एक की-व्हॅल्यू जोडी (किंवा शून्य) मिळवते
• LowEntry(K obj) : LowerKey(K obj) पद्धती प्रमाणेच, फक्त एक की-व्हॅल्यू जोडी (किंवा शून्य) मिळवते
• highEntry(K obj) : HigherKey(K obj) पद्धती प्रमाणेच, फक्त एक की-व्हॅल्यू जोडी (किंवा शून्य) मिळवते
• descendingKeySet() : उलट क्रमाने क्रमवारी लावलेल्या सर्व कळांचा समावेश असलेला NavigableSet परत करतो
• descendingMap() : उलट क्रमाने क्रमवारी लावलेल्या सर्व जोड्या असलेला NavigableMap परत करतो
• navigableKeySet() : ज्या क्रमाने ते संग्रहित केले जातात त्या क्रमाने सर्व कळा असलेले NavigableSet ऑब्जेक्ट परत करते
• headMap(K upperBound, boolean incl) : सुरुवातीपासून upperBound घटकापर्यंत जोड्या असलेला नकाशा मिळवतो. incl पॅरामीटर दर्शविते की परत केलेल्या नकाशामध्ये अप्परबाउंड घटक समाविष्ट करायचा की नाही
• tailMap(K LowerBound, boolean incl) : मागील पद्धतीसारखी कार्यक्षमता, लोअरबाउंडपासून शेवटपर्यंत फक्त जोड्या मिळवते
• subMap(K LowerBound, boolean lowIncl, K upperBound, boolean highIncl) : मागील पद्धतींप्रमाणे, लोअरबाउंड ते अप्परबाउंडपर्यंत जोड्या मिळवते; वितर्क lowIncl आणि highIncl नवीन नकाशामध्ये सीमा घटक समाविष्ट करायचे की नाही हे सूचित करतात.

नेहमीच्या कन्स्ट्रक्टर्स व्यतिरिक्त, TreeMap मध्ये आणखी एक कन्स्ट्रक्टर आहे जो तुलनाकर्त्याचे उदाहरण स्वीकारतो. घटक ज्या क्रमाने संग्रहित केले जातात त्यासाठी हा तुलनाकर्ता जबाबदार आहे.

TreeMap ची उदाहरणे

अतिरिक्त पद्धतींची ही विपुलता अनावश्यक वाटू शकते, परंतु ते पहिल्या दृष्टीक्षेपात आपल्या लक्षात येण्यापेक्षा जास्त उपयुक्त ठरतील. चला खालील उदाहरण एकत्र एक्सप्लोर करू. कल्पना करा की आम्ही एका मोठ्या कंपनीच्या मार्केटिंग विभागात काम करतो आणि आमच्याकडे अशा लोकांचा डेटाबेस आहे ज्यांना आम्हाला जाहिराती दाखवायच्या आहेत. लक्षात ठेवण्यासाठी दोन तपशील आहेत:

• आम्हाला प्रत्येक व्यक्तीच्या छापांच्या संख्येचा मागोवा ठेवणे आवश्यक आहे
• अल्पवयीन मुलांना जाहिराती दाखवण्याचा अल्गोरिदम वेगळा आहे.

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

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) {}
}

मुख्य वर्गात, एक TreeMap तयार करा, ज्यामध्ये प्रत्येक की विशिष्ट व्यक्तीचे प्रतिनिधित्व करते आणि प्रत्येक मूल्य या महिन्यात जाहिरात छापांची संख्या असते. आम्ही कन्स्ट्रक्टरला एक तुलनाकर्ता पास करतो जो वयानुसार लोकांची क्रमवारी लावतो. आम्ही अनियंत्रित मूल्यांसह नकाशा भरतो. आता आम्हाला आमच्या छोट्या डेटा भांडारात पहिल्या प्रौढ व्यक्तीचा संदर्भ मिळवायचा आहे. आम्ही हे स्ट्रीम API वापरून करतो. मग आम्हाला दोन स्वतंत्र नकाशे मिळतात, जे आम्ही जाहिराती दाखवणार्‍या पद्धतींना पास करतो. अनेक, अनेक मार्गांनी आपण हे कार्य पूर्ण करू शकलो असतो. TreeMap क्लासच्या पद्धतींचा शस्त्रागार आम्हाला प्रत्येक गरजेसाठी सानुकूल उपाय तयार करू देतो. तुम्हाला ते सर्व लक्षात ठेवण्याची गरज नाही, कारण तुम्ही तुमच्या IDE मधील कागदपत्रे किंवा टिप्स नेहमी वापरू शकता. तुम्ही जे शिकलात ते बळकट करण्यासाठी, आम्ही तुम्हाला आमच्या Java कोर्समधील व्हिडिओ धडा पाहण्याचा सल्ला देतो आतासाठी एवढेच! मला आशा आहे की ट्रीमॅप वर्ग आता तुम्हाला स्पष्ट झाला आहे आणि तुम्ही व्यावहारिक कोडिंग कार्ये सोडवण्यासाठी ते योग्यरित्या लागू कराल.