TreeMap కీలక అంశాల ఆధారంగా డేటాను క్రమబద్ధీకరించిన క్రమంలో నిల్వ చేస్తుంది. అధిక కీ డేటా (కీ-విలువ) ఈ డేటా నిర్మాణంలో చివరి స్థానంలో నిల్వ చేయబడుతుంది.
ట్రీమ్యాప్ సేకరణలో అందుబాటులో ఉన్న హైయర్‌కీ() మరియు లోయర్‌కీ() పద్ధతులను చర్చిద్దాం.
HigherKey()
TreeMap సేకరణలో highKey() పద్ధతి అందించిన కీ కంటే ఎక్కువ TreeMap సేకరణ వస్తువు నుండి కీని అందిస్తుంది. మేము ఈ కీని (పూర్ణాంక రకం) అధిక కీ() పద్ధతికి పారామీటర్‌గా అందించవచ్చు. అందించిన కీ కంటే ఎక్కువ ఉన్న అన్ని కీలలో ఫలిత కీ తక్కువగా ఉంటుంది.
సింటాక్స్:
చెట్టు పటం_వస్తువు. అధిక కీ ( కీ )ట్రీమ్యాప్_ఆబ్జెక్ట్ ట్రీమ్యాప్ సేకరణను సూచించే చోట.
పరామితి:
కీ పూర్ణాంకం రకం.
తిరిగి:
ఇది కలెక్షన్ ఆబ్జెక్ట్ నుండి కీని అందిస్తుంది.
గమనిక:
- ఉంటే ట్రీమ్యాప్ వస్తువు ఖాళీగా ఉంది, శూన్య తిరిగి ఇవ్వబడింది.
- అందించిన కీ అత్యధిక కీకి సమానంగా ఉంటే ట్రీమ్యాప్ వస్తువు, శూన్యం తిరిగి ఇవ్వబడుతుంది.
- అందించిన కీ అయితే శూన్య , NullPointerException పెంచబడుతుంది.
- ఉంటే ట్రీమ్యాప్ ఖాళీగా ఉంది మరియు మేము కీని శూన్యంగా అందిస్తే, శూన్య తిరిగి ఇవ్వబడింది.
దృష్టాంతంలో:
కింది జతలతో కూడిన ట్రీమ్యాప్‌ను పరిశీలిద్దాం:
{ ( 1000 , 'చైనా' ) , ( 2890 , 'UK' ) , ( 5000 , 'US' ) , ( 1500 , 'ఢిల్లీ' ) , ( 400 , 'జపాన్' ) }
ఇప్పుడు, highKey() పద్ధతిలో కీని 1000గా పేర్కొనండి.
కాబట్టి, 1000 కంటే ఎక్కువ ఉన్న కీలు:1500,2890 మరియు 5000. వాటిలో, 1500 చిన్నది. కాబట్టి, ఫలితం 1500.
ఉదాహరణ 1:
ఇక్కడ, మేము జనాభా గణనను కీలకంగా మరియు నగరం/రాష్ట్రాన్ని విలువగా నిల్వ చేసే TreeMap సేకరణను సృష్టిస్తాము. ఇప్పుడు, అధిక కీ() పద్ధతిని ఉపయోగించి అందించిన కీ కంటే తక్కువ లేదా సమానమైన కొన్ని కీలను మేము పొందుతాము.
దిగుమతి java.util.* ;దిగుమతి java.util.TreeMap ;
ప్రజా తరగతి ప్రధాన
{
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
// పూర్ణాంకం మరియు విలువ స్ట్రింగ్ రకాలుగా కీతో ట్రీమ్యాప్‌ను సృష్టించండి
ట్రీమ్యాప్ జనాభా_డేటా = కొత్త ట్రీమ్యాప్ ( ) ;
// జనాభా_డేటా ఆబ్జెక్ట్‌లో 5 విలువలను చొప్పించండి
జనాభా_డేటా. చాలు ( 1000 , 'చైనా' ) ;
జనాభా_డేటా. చాలు ( 2890 , 'UK' ) ;
జనాభా_డేటా. చాలు ( 5000 , 'US' ) ;
జనాభా_డేటా. చాలు ( 1500 , 'ఢిల్లీ' ) ;
జనాభా_డేటా. చాలు ( 400 , 'జపాన్' ) ;
వ్యవస్థ . బయటకు . println ( 'జనాభా:' + జనాభా_డేటా ) ;
// 1000 కంటే ఎక్కువ కీని పొందండి
వ్యవస్థ . బయటకు . println ( 'హయ్యర్‌కీ(1000):' + జనాభా_డేటా. అధిక కీ ( 1000 ) ) ;
// 400 కంటే ఎక్కువ కీని పొందండి
వ్యవస్థ . బయటకు . println ( 'హయ్యర్‌కీ(400):' + జనాభా_డేటా. అధిక కీ ( 400 ) ) ;
}
}
అవుట్‌పుట్:
- ఇచ్చిన కీ 1000. 1500 జనాభా_డేటాలో 1000 కంటే ఎక్కువ ఉన్న 1000 కంటే ఎక్కువ మరియు మిగిలిన కీల (2890, 5000) కంటే తక్కువగా ఉండే కీ.
- ఇచ్చిన కీ 400. 1000 జనాభా_డేటాలో 400 కంటే ఎక్కువ ఉన్న 400 కంటే ఎక్కువ మరియు మిగిలిన కీల (1500,2890,5000) కంటే తక్కువగా ఉండే కీ.
ఉదాహరణ 2:
కింది వాటిని అందజేద్దాం:
- 5000 కీ
- కీ వలె శూన్యం
దిగుమతి java.util.TreeMap ;
ప్రజా తరగతి ప్రధాన
{
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
// పూర్ణాంకం మరియు విలువ స్ట్రింగ్ రకాలుగా కీతో ట్రీమ్యాప్‌ను సృష్టించండి
ట్రీమ్యాప్ జనాభా_డేటా = కొత్త ట్రీమ్యాప్ ( ) ;
// జనాభా_డేటా ఆబ్జెక్ట్‌లో 5 విలువలను చొప్పించండి
జనాభా_డేటా. చాలు ( 1000 , 'చైనా' ) ;
జనాభా_డేటా. చాలు ( 2890 , 'UK' ) ;
జనాభా_డేటా. చాలు ( 5000 , 'US' ) ;
జనాభా_డేటా. చాలు ( 1500 , 'ఢిల్లీ' ) ;
జనాభా_డేటా. చాలు ( 400 , 'జపాన్' ) ;
వ్యవస్థ . బయటకు . println ( 'జనాభా:' + జనాభా_డేటా ) ;
// 5000 కంటే ఎక్కువ కీని పొందండి
వ్యవస్థ . బయటకు . println ( 'హయ్యర్‌కీ(5000):' + జనాభా_డేటా. అధిక కీ ( 5000 ) ) ;
// శూన్యం కంటే గొప్ప కీని పొందండి
వ్యవస్థ . బయటకు . println ( 'హయ్యర్‌కీ(శూన్యం):' + జనాభా_డేటా. అధిక కీ ( శూన్య ) ) ;
}
}
అవుట్‌పుట్:
- ఇచ్చిన కీ 5000. 5000 కంటే ఎక్కువ కీ లేదు. కాబట్టి, శూన్య తిరిగి ఇవ్వబడింది.
- ఇచ్చిన కీ శూన్యం, కాబట్టి NullPointerException తిరిగి ఇవ్వబడింది.
LowerKey()
TreeMap సేకరణలో lowKey() పద్ధతి అందించిన కీ కంటే తక్కువ TreeMap సేకరణ వస్తువు నుండి కీని అందిస్తుంది. మేము ఈ కీని (పూర్ణాంకం రకం) లోయర్‌కీ() పద్ధతికి పారామీటర్‌గా అందించవచ్చు. అందించిన కీ కంటే తక్కువగా ఉన్న అన్ని కీలలో ఫలిత కీ ఎక్కువగా ఉంటుంది.
సింటాక్స్:
చెట్టు పటం_వస్తువు. దిగువ కీ ( కీ )ట్రీమ్యాప్_ఆబ్జెక్ట్ ట్రీమ్యాప్ సేకరణను సూచించే చోట.
పరామితి:
కీ పూర్ణాంకం రకం.
తిరిగి:
ఇది కలెక్షన్ ఆబ్జెక్ట్ నుండి కీని అందిస్తుంది.
గమనిక:
- ఉంటే ట్రీమ్యాప్ వస్తువు ఖాళీగా ఉంది, శూన్య తిరిగి ఇవ్వబడింది.
- అందించిన కీ, లో అత్యల్ప కీకి సమానంగా ఉంటే ట్రీమ్యాప్ వస్తువు, శూన్యం తిరిగి ఇవ్వబడుతుంది.
- అందించిన కీ శూన్యం అయితే, NullPointerException పెంచబడుతుంది.
- ఉంటే ట్రీమ్యాప్ ఖాళీగా ఉంది మరియు మేము కీని శూన్యంగా అందిస్తే, శూన్య తిరిగి ఇవ్వబడింది.
దృష్టాంతంలో:
కింది జతలతో కూడిన ట్రీమ్యాప్‌ను పరిశీలిద్దాం:
{ ( 1000 , 'చైనా' ) , ( 2890 , 'UK' ) , ( 5000 , 'US' ) , ( 1500 , 'ఢిల్లీ' ) , ( 400 , 'జపాన్' ) }ఇప్పుడు, lowerKey() పద్ధతిలో కీని 5000గా పేర్కొనండి.
5000 కంటే తక్కువ ఉన్న కీలు: 2890,1500,1000 మరియు 400. వాటిలో, 2890 పెద్దది. కాబట్టి, ఫలితం 2890.
ఉదాహరణ 1:
ఇక్కడ, మేము జనాభా గణనను కీలకంగా మరియు నగరం/రాష్ట్రాన్ని విలువగా నిల్వ చేసే TreeMap సేకరణను సృష్టిస్తాము. ఇప్పుడు, అధిక కీ() పద్ధతిని ఉపయోగించి అందించిన కీ కంటే తక్కువ లేదా సమానమైన కొన్ని కీలను మేము పొందుతాము.
దిగుమతి జావా ఉపయోగపడుతుంది . *;దిగుమతి జావా ఉపయోగపడుతుంది . ట్రీమ్యాప్ ;
ప్రజా తరగతి ప్రధాన
{
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
// పూర్ణాంకం మరియు విలువ స్ట్రింగ్ రకాలుగా కీతో ట్రీమ్యాప్‌ను సృష్టించండి
TreeMap జనాభా_డేటా = కొత్త ట్రీమ్యాప్ ( ) ;
// జనాభా_డేటా ఆబ్జెక్ట్‌లో 5 విలువలను చొప్పించండి
జనాభా_డేటా. చాలు ( 1000 , 'చైనా' ) ;
జనాభా_డేటా. చాలు ( 2890 , 'UK' ) ;
జనాభా_డేటా. చాలు ( 5000 , 'US' ) ;
జనాభా_డేటా. చాలు ( 1500 , 'ఢిల్లీ' ) ;
జనాభా_డేటా. చాలు ( 400 , 'జపాన్' ) ;
వ్యవస్థ. బయటకు . println ( 'జనాభా:' + జనాభా_డేటా ) ;
// 5000 కంటే తక్కువ ఉన్న కీని పొందండి
వ్యవస్థ. బయటకు . println ( 'lowerKey(5000): ' + జనాభా_డేటా. దిగువ కీ ( 5000 ) ) ;
// 400 కంటే తక్కువ ఉన్న కీని పొందండి
వ్యవస్థ. బయటకు . println ( 'lowerKey(400):' + జనాభా_డేటా. దిగువ కీ ( 400 ) ) ;
}
}
అవుట్‌పుట్:
- ఇచ్చిన కీ 5000. 2890 జనాభా_డేటాలో 5000 కంటే తక్కువ ఉన్న మిగిలిన కీల (1000,1500) కంటే 5000 కంటే తక్కువ మరియు పెద్దది.
- ఇచ్చిన కీ 400 . 400 కంటే తక్కువ కీ లేదు. కాబట్టి, శూన్య తిరిగి ఇవ్వబడింది.
ఉదాహరణ 2:
శూన్యాన్ని కీగా అందజేద్దాం.
దిగుమతి జావా ఉపయోగపడుతుంది . *;దిగుమతి జావా ఉపయోగపడుతుంది . ట్రీమ్యాప్ ;
ప్రజా తరగతి ప్రధాన
{
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
// పూర్ణాంకం మరియు విలువ స్ట్రింగ్ రకాలుగా కీతో ట్రీమ్యాప్‌ను సృష్టించండి
TreeMap జనాభా_డేటా = కొత్త ట్రీమ్యాప్ ( ) ;
// జనాభా_డేటా ఆబ్జెక్ట్‌లో 5 విలువలను చొప్పించండి
జనాభా_డేటా. చాలు ( 1000 , 'చైనా' ) ;
జనాభా_డేటా. చాలు ( 2890 , 'UK' ) ;
జనాభా_డేటా. చాలు ( 5000 , 'US' ) ;
జనాభా_డేటా. చాలు ( 1500 , 'ఢిల్లీ' ) ;
జనాభా_డేటా. చాలు ( 400 , 'జపాన్' ) ;
వ్యవస్థ. బయటకు . println ( 'జనాభా:' + జనాభా_డేటా ) ;
// శూన్యం కంటే తక్కువగా ఉండే కీని పొందండి
వ్యవస్థ. బయటకు . println ( 'lowerKey(శూన్య):' + జనాభా_డేటా. దిగువ కీ ( శూన్య ) ) ;
}
}
అవుట్‌పుట్:
ఇచ్చిన కీ శూన్య . కాబట్టి, NullPointerException తిరిగి ఇవ్వబడింది.
ముగింపు
మేము జావా ట్రీమ్యాప్ సేకరణలో అధిక కీ() మరియు లోయర్‌కీ() గురించి చర్చించాము. హైయర్‌కీ() అందించిన కీ కంటే ఎక్కువ ఉన్న అన్ని కీలలో తక్కువగా ఉండే కీని అందిస్తుంది. లోయర్‌కీ() అందించిన కీ కంటే తక్కువగా ఉన్న అన్ని కీలలో ఎక్కువ కీని అందిస్తుంది. NullPointerException మేము ఈ రెండు పద్ధతులకు ఒక పరామితిని శూన్యంగా పేర్కొన్నప్పుడు సంభవిస్తుంది.