జావాలో ట్రీమ్యాప్

మీరు ఈ కథనాన్ని చదువుతున్నట్లయితే, మీరు మ్యాప్ ఇంటర్‌ఫేస్‌తో ఎక్కువగా సుపరిచితులై ఉంటారు మరియు తగిన విధంగా ఎక్కడ వర్తించవచ్చు. లేకపోతే, ఇక్కడకు రండి . ఈ రోజు మనం జావా ట్రీమ్యాప్ అమలు యొక్క లక్షణాల గురించి మాట్లాడుతాము మరియు మరింత ప్రత్యేకంగా, ఇది HashMap నుండి ఎలా భిన్నంగా ఉంటుంది మరియు దానిని సరిగ్గా ఎలా ఉపయోగించాలి.

TreeMap, HashMap మరియు LinkedHashMap పోల్చడం

మ్యాప్ ఇంటర్‌ఫేస్‌లో ఎక్కువగా ఉపయోగించే అమలు హాష్‌మ్యాప్. ఇది ఉపయోగించడం సులభం మరియు డేటాకు శీఘ్ర ప్రాప్యతకు హామీ ఇస్తుంది, కాబట్టి ఇది చాలా సమస్యలను పరిష్కరించడానికి ఉత్తమ అభ్యర్థి. చాలా, కానీ అన్నీ కాదు. కొన్నిసార్లు మీరు డేటాను నిర్మాణాత్మక మార్గంలో నిల్వ చేయాలి మరియు దాని ద్వారా నావిగేట్ చేయగలరు. ఈ సందర్భంలో, మ్యాప్ ఇంటర్‌ఫేస్ (ట్రీమ్యాప్) యొక్క మరొక అమలు రక్షణకు వస్తుంది. ట్రీమ్యాప్ నావిగేబుల్ మ్యాప్ ఇంటర్‌ఫేస్‌ను అమలు చేస్తుంది, ఇది క్రమబద్ధీకరించబడిన మ్యాప్‌ను వారసత్వంగా పొందుతుంది , ఇది మ్యాప్ ఇంటర్‌ఫేస్‌ను వారసత్వంగా పొందుతుంది. నావిగేబుల్ మ్యాప్ మరియు క్రమబద్ధీకరించబడిన మ్యాప్ ఇంటర్‌ఫేస్‌లను అమలు చేయడం ద్వారా , ట్రీమ్యాప్ హ్యాష్‌మ్యాప్‌లో అందుబాటులో లేని అదనపు కార్యాచరణను పొందుతుంది, అయితే ఇది పనితీరు పరంగా ధరను చెల్లిస్తుంది. లింక్డ్ హాష్ మ్యాప్ కూడా ఉందితరగతి , ఇది డేటాను నిర్దిష్ట క్రమంలో నిల్వ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది (మీరు దానిని మ్యాప్‌కి జోడించే క్రమం). ఈ మూడు తరగతుల మధ్య తేడాలను అర్థం చేసుకోవడానికి , ఈ పట్టికను చూడండి: మీరు చూడగలిగినట్లుగా, ఈ తరగతులు చాలా సాధారణమైనవి, కానీ అనేక తేడాలు కూడా ఉన్నాయి. ట్రీమ్యాప్ తరగతి చాలా బహుముఖంగా ఉన్నప్పటికీ, ఇది ఎల్లప్పుడూ శూన్యతను కీగా నిల్వ చేయదు. అదనంగా, TreeMap యొక్క మూలకాలను యాక్సెస్ చేయడానికి ఎక్కువ సమయం పడుతుంది. కాబట్టి, మీరు డేటాను కొన్ని క్రమబద్ధీకరించిన క్రమంలో నిల్వ చేయనవసరం లేకుంటే, HashMap లేదా LinkedHashMapని ఉపయోగించడం మంచిది .

ఎరుపు-నలుపు చెట్టు

హుడ్ కింద, ట్రీమ్యాప్ ఎరుపు-నలుపు చెట్టు అని పిలువబడే డేటా నిర్మాణాన్ని ఉపయోగిస్తుందని మీరు బహుశా గమనించి ఉండవచ్చు. ఈ నిర్మాణంలో డేటాను నిల్వ చేయడం అనేది ఖచ్చితంగా డేటా క్రమాన్ని అందిస్తుంది. కాబట్టి ఇది ఎలాంటి చెట్టు? దాన్ని గుర్తించండి! మీరు నంబర్-స్ట్రింగ్ జతలను నిల్వ చేయాల్సిన అవసరం ఉందని ఊహించండి. 16, 20, 52, 55, 61, 65, 71, 76, 81, 85, 90, 93 మరియు 101 సంఖ్యలు కీలుగా ఉంటాయి. మీరు సాంప్రదాయ జాబితాలో డేటాను నిల్వ చేస్తే మరియు మీరు కీ 101తో మూలకాన్ని కనుగొనవలసి ఉంటే, దాన్ని కనుగొనడానికి మీరు మొత్తం 13 మూలకాల ద్వారా అడుగు వేయాలి. 13 అంశాల కోసం, ఇది పెద్ద విషయం కాదు, కానీ మిలియన్‌తో పని చేస్తున్నప్పుడు, మాకు పెద్ద సమస్యలు వస్తాయి. ఈ సమస్యలను పరిష్కరించడానికి, ప్రోగ్రామర్లు కొంచెం సంక్లిష్టమైన డేటా నిర్మాణాలను ఉపయోగిస్తారు. ఎరుపు-నలుపు చెట్టు వేదికపైకి వచ్చేది ఇక్కడే!మూలకం కోసం శోధించడం చెట్టు యొక్క మూలం వద్ద ప్రారంభమవుతుంది, ఇది మా సందర్భంలో 61. ఆపై మేము నోడ్ విలువలను మనం వెతుకుతున్న విలువతో సరిపోల్చండి. మన విలువ తక్కువగా ఉంటే, అప్పుడు మనం ఎడమ వైపుకు వెళ్తాము; అది ఎక్కువగా ఉంటే, మేము కుడి వైపుకు వెళ్తాము. మనం కోరుకున్న విలువను కనుగొనే వరకు లేదా విలువ శూన్యమైన (చెట్టు యొక్క ఆకు) మూలకాన్ని ఎదుర్కొనే వరకు ఈ ప్రక్రియ పునరావృతమవుతుంది . చెట్టును నావిగేట్ చేయడం మరియు బ్యాలెన్స్ చేయడం సులభతరం చేయడానికి ఎరుపు మరియు నలుపు రంగులు ఉపయోగించబడతాయి. ఎరుపు-నలుపు చెట్టును నిర్మించేటప్పుడు ఎల్లప్పుడూ గమనించవలసిన నియమాలు ఉన్నాయి:

• మూలం నల్లగా ఉండాలి.
• చెట్టు ఆకులు నల్లగా ఉండాలి.
• ఎరుపు నోడ్‌లో తప్పనిసరిగా రెండు బ్లాక్ చైల్డ్ నోడ్‌లు ఉండాలి.
• బ్లాక్ నోడ్ ఏదైనా రంగు యొక్క చైల్డ్ నోడ్‌లను కలిగి ఉంటుంది.
• నోడ్ నుండి దాని ఆకుల వరకు ఉండే మార్గంలో తప్పనిసరిగా అదే సంఖ్యలో బ్లాక్ నోడ్‌లు ఉండాలి.
• కొత్త నోడ్స్ ఆకులకు జోడించబడతాయి.

మీరు నియమాలు 3, 4 మరియు 5ని కలిపి పరిశీలిస్తే, నోడ్ రంగు చెట్టును మరింత త్వరగా నావిగేట్ చేయడానికి ఎలా అనుమతిస్తుందో మీరు అర్థం చేసుకోవచ్చు: నలుపు నోడ్‌ల ద్వారా మార్గం ఎల్లప్పుడూ ఎరుపు నోడ్‌ల ద్వారా ఒకటి కంటే తక్కువగా ఉంటుంది. దీని ప్రకారం, చెట్టు యొక్క మొత్తం పరిమాణం బ్లాక్ నోడ్స్ సంఖ్య ద్వారా నిర్ణయించబడుతుంది, దీనిని "నలుపు ఎత్తు" అని పిలుస్తారు. ఎరుపు-నలుపు చెట్టు డేటా నిర్మాణం వివిధ ప్రోగ్రామింగ్ భాషలలో అమలు చేయబడుతుంది. ఇంటర్నెట్‌లో చాలా జావా ఇంప్లిమెంటేషన్‌లు ఉన్నాయి, కాబట్టి మేము ఇక్కడ ఆలస్యం చేయము. బదులుగా, TreeMap యొక్క కార్యాచరణను తెలుసుకోవడం కొనసాగిద్దాం.

క్రమబద్ధీకరించబడిన మ్యాప్ మరియు నావిగేబుల్ మ్యాప్ ఇంటర్‌ఫేస్‌ల నుండి వచ్చే పద్ధతులు

HashMap వలె, TreeMap Map ఇంటర్‌ఫేస్‌ను అమలు చేస్తుంది, అంటే TreeMap HashMapలో ఉన్న అన్ని పద్ధతులను కలిగి ఉంటుంది. కానీ ట్రీమ్యాప్ క్రమబద్ధీకరించబడిన మ్యాప్ మరియు నావిగేబుల్ మ్యాప్ ఇంటర్‌ఫేస్‌లను కూడా అమలు చేస్తుంది మరియు తద్వారా వాటి నుండి అదనపు కార్యాచరణను పొందుతుంది. క్రమబద్ధీకరించబడిన మ్యాప్ అనేది మ్యాప్‌ను విస్తరించే మరియు క్రమబద్ధీకరించబడిన డేటాసెట్‌కు సంబంధించిన పద్ధతులను జోడించే ఇంటర్‌ఫేస్ :

• firstKey() : మ్యాప్‌లోని మొదటి మూలకం యొక్క కీని అందిస్తుంది
• lastKey() : చివరి మూలకం యొక్క కీని అందిస్తుంది
• హెడ్‌మ్యాప్(కె ఎండ్) : ప్రస్తుత మ్యాప్‌లోని అన్ని ఎలిమెంట్‌లను కలిగి ఉన్న మ్యాప్‌ను మొదటి నుండి కీ ఎండ్ ఉన్న ఎలిమెంట్ వరకు అందిస్తుంది
• tailMap(K ప్రారంభం) : ప్రారంభ మూలకం నుండి చివరి వరకు ప్రస్తుత మ్యాప్‌లోని అన్ని అంశాలను కలిగి ఉన్న మ్యాప్‌ను అందిస్తుంది
• subMap(K ప్రారంభం, K ముగింపు) : ప్రారంభ మూలకం నుండి కీ ముగింపుతో ఉన్న మూలకం వరకు ప్రస్తుత మ్యాప్‌లోని అన్ని అంశాలను కలిగి ఉన్న మ్యాప్‌ను అందిస్తుంది.

NavigableMap అనేది క్రమబద్ధీకరించబడిన మ్యాప్‌ను విస్తరించే ఇంటర్‌ఫేస్ మరియు మ్యాప్‌లోని అంశాల మధ్య నావిగేట్ చేయడానికి పద్ధతులను జోడిస్తుంది:

• firstEntry() : మొదటి కీ-విలువ జతను అందిస్తుంది
• lastEntry() : చివరి కీ-విలువ జతను అందిస్తుంది
• pollFirstEntry() : మొదటి జతని తిరిగి ఇస్తుంది మరియు తొలగిస్తుంది
• పోల్‌లాస్ట్‌ఎంట్రీ() : చివరి జతని తిరిగి ఇస్తుంది మరియు తొలగిస్తుంది
• సీలింగ్‌కీ(K obj) : కీ obj కంటే ఎక్కువ లేదా సమానమైన అతి చిన్న కీ kని అందిస్తుంది. అటువంటి కీ లేనట్లయితే, శూన్యతను అందిస్తుంది
• floorKey(K obj) : కీ obj కంటే తక్కువ లేదా సమానమైన అతిపెద్ద కీ kని అందిస్తుంది. అటువంటి కీ లేనట్లయితే, శూన్యతను అందిస్తుంది
• lowKey(K obj) : కీ obj కంటే తక్కువ ఉన్న అతిపెద్ద కీ kని అందిస్తుంది. అటువంటి కీ లేనట్లయితే, శూన్యతను అందిస్తుంది
• highKey(K obj) : కీ obj కంటే పెద్దది అయిన అతి చిన్న కీ kని అందిస్తుంది. అటువంటి కీ లేనట్లయితే, శూన్యతను అందిస్తుంది
• సీలింగ్‌ఎంట్రీ(K obj) : సీలింగ్‌కే (K obj) పద్ధతిని పోలి ఉంటుంది, కీ-విలువ జత (లేదా శూన్య) మాత్రమే అందిస్తుంది
• ఫ్లోర్‌ఎంట్రీ(K obj) : ఫ్లోర్‌కీ(K obj) పద్ధతిని పోలి ఉంటుంది, కీ-విలువ జత (లేదా శూన్య) మాత్రమే అందిస్తుంది
• lowEntry(K obj) : lowKey(K obj) పద్ధతిని పోలి ఉంటుంది, కీ-విలువ జత (లేదా శూన్యం) మాత్రమే అందిస్తుంది
• highEntry(K obj) : అధిక కీ(K obj) పద్ధతి వలె, కీ-విలువ జత (లేదా శూన్య) మాత్రమే అందిస్తుంది
• descendingKeySet() : రివర్స్ ఆర్డర్‌లో క్రమబద్ధీకరించబడిన అన్ని కీలను కలిగి ఉన్న నావిగేబుల్‌సెట్‌ను అందిస్తుంది
• descendingMap() : రివర్స్ ఆర్డర్‌లో క్రమబద్ధీకరించబడిన అన్ని జతలను కలిగి ఉన్న నావిగేబుల్ మ్యాప్‌ను అందిస్తుంది
• navigableKeySet() : అవి నిల్వ చేయబడిన క్రమంలో అన్ని కీలను కలిగి ఉన్న NavigableSet వస్తువును అందిస్తుంది
• headMap(K అప్పర్‌బౌండ్, బూలియన్ సహా) : మొదటి నుండి అప్పర్‌బౌండ్ మూలకం వరకు జతలను కలిగి ఉన్న మ్యాప్‌ను అందిస్తుంది. incl పరామితి తిరిగి వచ్చిన మ్యాప్‌లో అప్పర్‌బౌండ్ మూలకాన్ని చేర్చాలా వద్దా అని సూచిస్తుంది
• tailMap(K లోయర్‌బౌండ్, బూలియన్ సహా) : మునుపటి పద్ధతికి సమానమైన కార్యాచరణ, లోయర్‌బౌండ్ నుండి చివరి వరకు జతలను మాత్రమే అందిస్తుంది
• సబ్‌మ్యాప్(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) {}
}

ప్రధాన తరగతిలో, ట్రీమ్యాప్‌ను సృష్టించండి, దీనిలో ప్రతి కీ నిర్దిష్ట వ్యక్తిని సూచిస్తుంది మరియు ప్రతి విలువ ఈ నెలలో ఉన్న ప్రకటన ప్రభావాల సంఖ్య. మేము కన్స్ట్రక్టర్‌కు వ్యక్తులను వయస్సు ప్రకారం క్రమబద్ధీకరించే కంపారిటర్‌ని పంపుతాము. మేము ఏకపక్ష విలువలతో మ్యాప్‌ని నింపుతాము. ఇప్పుడు మేము మా చిన్న డేటా రిపోజిటరీలో మొదటి పెద్దలకు సూచనను పొందాలనుకుంటున్నాము. మేము స్ట్రీమ్ APIని ఉపయోగించి దీన్ని చేస్తాము. అప్పుడు మేము రెండు వేర్వేరు మ్యాప్‌లను పొందుతాము, వీటిని మేము ప్రకటనలను చూపించే పద్ధతులకు పంపుతాము. ఈ పనిని మనం సాధించగలిగే అనేక మార్గాలు ఉన్నాయి. ట్రీమ్యాప్ క్లాస్ యొక్క ఆర్సెనల్ ఆఫ్ మెథడ్స్ ప్రతి అవసరానికి అనుకూల పరిష్కారాలను రూపొందించడానికి మమ్మల్ని అనుమతిస్తుంది. మీరు వాటన్నింటినీ గుర్తుంచుకోవాల్సిన అవసరం లేదు, ఎందుకంటే మీరు ఎల్లప్పుడూ మీ IDE నుండి డాక్యుమెంటేషన్ లేదా చిట్కాలను ఉపయోగించవచ్చు. మీరు నేర్చుకున్న వాటిని బలోపేతం చేయడానికి, మా జావా కోర్సు నుండి వీడియో పాఠాన్ని చూడమని మేము మీకు సూచిస్తున్నాము ఇప్పటికి ఇంతే! ట్రీమ్యాప్ క్లాస్ ఇప్పుడు మీకు స్పష్టంగా ఉందని మరియు ఆచరణాత్మక కోడింగ్ టాస్క్‌లను పరిష్కరించడంలో మీరు దానిని సరిగ్గా వర్తింపజేస్తారని నేను ఆశిస్తున్నాను.