జావాలో మ్యాప్ ఇంటర్‌ఫేస్

జావా మ్యాప్ ఇంటర్‌ఫేస్ అంటే ఏమిటి

జావా మ్యాప్ ఇంటర్‌ఫేస్ జావా కలెక్షన్ ఫ్రేమ్‌వర్క్‌లో ఒక భాగం, అయితే ఇది కలెక్షన్ ఇంటర్‌ఫేస్ యొక్క ఉప రకం కాదు. కనుక ఇది జాబితాలు లేదా ఇతర సేకరణ వస్తువులతో పోల్చితే భిన్నమైన రీతిలో ప్రవర్తిస్తుంది. మ్యాప్ <కీ, విలువ>లోని ప్రతి మూలకం కీ-విలువ జతను సూచిస్తుంది. కీ మరియు విలువ రెండూ కొన్ని వస్తువులు. నిర్దిష్ట మ్యాప్‌లోని అన్ని కీలు ప్రత్యేకమైనవి, అయితే విలువలు ఉండవు, కాబట్టి అవి నకిలీ చేయబడతాయి. మీరు జావాలో ఒక రకమైన డిక్షనరీ లేదా ఆన్‌లైన్-షాప్ కేటలాగ్ వంటి మ్యాప్ గురించి ఆలోచించవచ్చు, ఇక్కడ మీరు దాని ప్రత్యేక సూచికను ఉపయోగించి ఏదైనా వస్తువును కనుగొనవచ్చు. కీ అనేది మ్యాప్‌లోని విలువ యొక్క ప్రత్యేక ఐడెంటిఫైయర్. ఉదాహరణకు మ్యాప్‌లో <స్ట్రింగ్, ఐటెమ్> స్ట్రింగ్ అనేది ఆన్‌లైన్ షాప్ నుండి కొంత వస్తువు యొక్క ID. డాక్యుమెంటేషన్ల ప్రకారం మ్యాప్ తదుపరి ఉప ఇంటర్‌ఫేస్‌లను కలిగి ఉంది:

బైండింగ్స్ ;
• ConcurrentMap<K,V> ;
• ConcurrentNavigableMap<K,V> ;
• LogicalMessageContext ;
• సందేశ సందర్భం ;
• నావిగేబుల్ మ్యాప్<K,V> ;
• SOAPMessageContext ;
• క్రమబద్ధీకరించబడిన మ్యాప్<K,V> .

మరియు తరగతులను అమలు చేస్తుంది:

• వియుక్త మ్యాప్
• గుణాలు
• AuthProvider
• కాంకరెంట్ హాష్ మ్యాప్
• ConcurrentSkipListMap
• EnumMap
• హాష్ మ్యాప్
• హ్యాష్టబుల్
• గుర్తింపు హాష్ మ్యాప్
• లింక్డ్ హాష్ మ్యాప్
• ప్రింటర్ స్టేట్ కారణాలు
• లక్షణాలు
• ప్రొవైడర్
• రెండరింగ్ సూచనలు
• సింపుల్ బైండింగ్స్
• TabularDataSupport
• ట్రీమ్యాప్
• UIDఫాల్ట్‌లు
• బలహీనమైన హాష్ మ్యాప్

• జావా అబ్‌స్ట్రాక్ట్ మ్యాప్ అనేది మ్యాప్ ఇంటర్‌ఫేస్‌లో చాలా వరకు అమలు చేసే వియుక్త తరగతి.
• Java HashMap అనేది హ్యాష్ పట్టికను ఉపయోగించి కీ-విలువ జతలను నిల్వ చేయడానికి డేటా నిర్మాణం.
• జావా ట్రీమ్యాప్ అనేది ట్రీని ఉపయోగించడానికి ఒక డేటా నిర్మాణం, అంటే క్రమబద్ధీకరించబడిన కీలతో ప్రదర్శించబడుతుంది.
• బలహీనమైన కీలతో హాష్ పట్టికను ఉపయోగించడానికి WeakHashMap , విలువలతో ప్రదర్శించబడుతుంది, వాటిని ఇకపై ఉపయోగించకపోతే చెత్త కలెక్టర్ ద్వారా తొలగించవచ్చు.
• లింక్డ్‌హాష్‌మ్యాప్ అనేది ఎలిమెంట్‌లను జోడించే క్రమంతో కూడిన మ్యాప్, చొప్పించే క్రమంలో పునరావృతం చేయడానికి అనుమతిస్తుంది.
• EnumMap enum కీలతో ఉపయోగం కోసం AbstractMap తరగతిని విస్తరించింది .
IdentityHashMap డాక్యుమెంట్‌లను పోల్చినప్పుడు రెఫరెన్షియల్ ఈక్వివలెన్స్ చెకింగ్‌ని ఉపయోగిస్తుంది, ఈక్వల్స్() పద్ధతికి బదులుగా == ఆపరేషన్‌ని ఉపయోగించి పోల్చినప్పుడు కీలతో మ్యాపింగ్ చేస్తుంది

ఇక్కడ మేము మ్యాప్ ఇంటర్‌ఫేస్ యొక్క అత్యంత జనాదరణ పొందిన అమలులపై ఆసక్తి కలిగి ఉన్నాము: HashMap, TreeMap మరియు LinkedHashMap. మార్గం ద్వారా, మ్యాప్ మూలకాల క్రమం నిర్దిష్ట అమలులపై ఆధారపడి ఉంటుంది. చెప్పండి, TreeMap మరియు LinkedHashMap మూలకాల యొక్క ఊహాజనిత క్రమాన్ని కలిగి ఉన్నాయి, అయితే HashMap లేదు.

మ్యాప్ పద్ధతులు

ఏదైనా మ్యాప్ యొక్క ప్రధాన కార్యకలాపాలు అంశాల చొప్పించడం, తీసివేయడం మరియు శోధన.

• పబ్లిక్ ఆబ్జెక్ట్ పుట్ (ఆబ్జెక్ట్ కీ, ఆబ్జెక్ట్ విలువ) మ్యాప్‌లోకి ఒక మూలకాన్ని చొప్పిస్తుంది.
• పబ్లిక్ శూన్యమైన putAll(మ్యాప్ మ్యాప్) మ్యాప్ లోపల పేర్కొన్న మ్యాప్‌ను ఇన్‌సర్ట్ చేస్తుంది.
• పబ్లిక్ ఆబ్జెక్ట్ రిమూవ్ (ఆబ్జెక్ట్ కీ) పేర్కొన్న కీ ప్రకారం ఎంట్రీని తొలగిస్తుంది.
• పబ్లిక్ ఆబ్జెక్ట్ గెట్ (ఆబ్జెక్ట్ కీ) పేర్కొన్న కీకి విలువను అందిస్తుంది.
• పబ్లిక్ బూలియన్ కలిగి ఉన్న కీ(ఆబ్జెక్ట్ కీ) ఈ మ్యాప్ నుండి పేర్కొన్న కీని శోధిస్తుంది
• పబ్లిక్ సెట్ కీసెట్() అన్ని కీలను కలిగి ఉన్న సెట్ వీక్షణను అందిస్తుంది
• పబ్లిక్ సెట్ ఎంట్రీసెట్() అన్ని కీలు మరియు విలువలతో సెట్ వీక్షణను అందిస్తుంది.

HashMap అంటే ఏమిటి

HashMap అంటే ఏమిటి? ఇది మ్యాప్ <కీ,విలువ> ఇంటర్‌ఫేస్ యొక్క అత్యంత ప్రజాదరణ పొందిన అమలు. ఈ డేటా నిర్మాణం హ్యాషింగ్ సూత్రంపై ఆధారపడి ఉంటుంది.

HashMap పని యొక్క ప్రధాన సూత్రం: హాషింగ్

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

1. నిర్దిష్ట ఇన్‌పుట్ (ఆబ్జెక్ట్) నిర్దిష్ట హాష్ కోడ్‌ని కలిగి ఉంటుంది.
2. రెండు వస్తువులు సమానంగా ఉంటే, వాటి హాష్ కోడ్‌లు కూడా సమానంగా ఉంటాయి. రివర్స్ నిజం కాదు.
3. హాష్ కోడ్‌లు భిన్నంగా ఉంటే, వస్తువులు ఖచ్చితంగా సమానంగా ఉండవు.
4. కొన్నిసార్లు వేర్వేరు వస్తువులు ఒకే హాష్ కోడ్‌ను కలిగి ఉండవచ్చు. ఇది చాలా అసంభవమైన సంఘటన, దీనికి "కొలిషన్" అని పేరు పెట్టారు మరియు మంచి నాణ్యత గల హాష్ ఫంక్షన్ ఘర్షణల సంభావ్యతను తగ్గించాలి.

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

HashMap: ఇది ఎలా పని చేస్తుంది

కాబట్టి క్లాస్ HashMap<K,V> ప్రతి మ్యాప్ అమలు కీలు మరియు విలువలను కలిగి ఉంటుంది. ఇది హ్యాషింగ్ సూత్రాలను ఉపయోగించి కీలను నిల్వ చేస్తుంది. హాష్‌మ్యాప్ కీ-విలువ జతల లోపల "బకెట్లు"లో నిల్వ చేయబడతాయి, ఈ బకెట్‌లు కలిసి ఒక "టేబుల్"ని నిర్మిస్తాయి, అంతర్గత లింక్డ్ జాబితాల శ్రేణి మరియు దాని ప్రారంభ పరిమాణం 16. జావాలోని హాష్‌మ్యాప్ కీ/విలువ జత మ్యాప్ చేయాల్సిన బకెట్‌ను గుర్తించడానికి కీ యొక్క హ్యాష్‌కోడ్‌ను ఉపయోగిస్తుంది: హాష్‌మ్యాప్ యొక్క గమ్మత్తైన లక్షణం ఏమిటంటే, టేబుల్‌లోని ప్రతి సెల్ (బకెట్) ఒక జత మాత్రమే కాకుండా అనేకం ఉంచుతుంది. అవి స్పష్టమైన వస్తువుగా నిల్వ చేయబడవు (లింక్డ్‌లిస్ట్ వంటివి), కానీ ఒక అవ్యక్త గొలుసు వలె. ప్రతి జత తదుపరి జతకి లింక్‌ను నిల్వ చేస్తుంది అనే వాస్తవం కారణంగా గొలుసు సృష్టించబడుతుంది. అంటే, అన్ని HashMap జతల 16 గొలుసులలో చెల్లాచెదురుగా ఉన్నాయి. మీరు పట్టికలో కొత్త జతని ఉంచినప్పుడు, కీ యొక్క హాష్ పరిగణించబడుతుంది. ఈ హాష్ కీ ఆబ్జెక్ట్‌లో నిర్మించిన హ్యాష్‌కోడ్ ఫంక్షన్ కాదు. ఇది 0-15 పరిధిలో పరిగణించబడుతుంది. హాష్ ఇండెక్స్‌తో బకెట్‌లో నిల్వ చేయబడిన జతల గొలుసుకు జత జోడించబడింది. ఈ విధానం మనకు శోధన త్వరణాన్ని అందిస్తుంది. కీ ద్వారా జత కోసం శోధిస్తున్నప్పుడు, మొత్తం పట్టిక ద్వారా వెళ్లవలసిన అవసరం లేదు. కీ యొక్క హాష్ పరిగణించబడుతుంది మరియు హాష్ సూచికతో సెల్‌లో నిల్వ చేయబడిన గొలుసు మాత్రమే తనిఖీ చేయబడుతుంది. HashMapలో చాలా జంటలు ఉంటే, గొలుసులు చాలా పొడవుగా మారతాయి. అప్పుడు శ్రేణి పరిమాణం పెరుగుతుంది, నిల్వ చేయబడిన అన్ని వస్తువుల హాష్ మళ్లీ లెక్కించబడుతుంది మరియు అవి కొత్త గొలుసుల వెంట చెల్లాచెదురుగా ఉంటాయి.

HashMap డిక్లరేషన్

మీరు తరగతి హాష్‌మ్యాప్ కోడ్‌కి వెళితే మీరు తదుపరి డిక్లరేషన్‌ను కనుగొంటారు:

public class HashMap extends AbstractMap implements Map, Cloneable, Serializable

ఇక్కడ K అనేది ఈ మ్యాప్ ద్వారా నిర్వహించబడే కీల రకం మరియు V - మ్యాప్ చేయబడిన విలువల రకం. ఇది మీ కోడ్‌లోని పూర్ణాంకం కీ మరియు స్ట్రింగ్ విలువతో కూడిన HashMap డిక్లరేషన్‌కి ఉదాహరణ:

HashMap<Integer, String> myHashMap = new HashMap<Integer, String>();

HashMap పద్ధతులు

ఇక్కడ HashMap పద్ధతుల జాబితా ఉంది.

• ఆబ్జెక్ట్ గెట్ (ఆబ్జెక్ట్ కీ) పేర్కొన్న కీకి విలువను అందిస్తుంది;
• ఆబ్జెక్ట్ పుట్(కీ k, విలువ v) కీ విలువ మ్యాపింగ్‌ను మ్యాప్‌లోకి చొప్పిస్తుంది;
• ఆబ్జెక్ట్ రిమూవ్ (ఆబ్జెక్ట్ కీ) ఈ మ్యాప్ నుండి పేర్కొన్న కీ కోసం మ్యాపింగ్‌ను తీసివేస్తుంది;
• void clear() HashMap నుండి అన్ని కీ-విలువ జతలను తొలగిస్తుంది;
• ఆబ్జెక్ట్ క్లోన్() కీలు మరియు విలువలను క్లోనింగ్ చేయకుండానే ఈ HashMap ఉదాహరణ యొక్క నిస్సార కాపీని అందిస్తుంది;
• మ్యాప్‌లో పేర్కొన్న కీ కనుగొనబడితే boolean కలిగి ఉన్న కీ(ఆబ్జెక్ట్ కీ) ఒప్పు అని, లేకపోతే తప్పు అని చూపుతుంది;
• మ్యాప్‌లో పేర్కొన్న కీ కనుగొనబడితే boolean కలిగి విలువ(ఆబ్జెక్ట్ విలువ) ఒప్పు అని, లేకపోతే తప్పు అని చూపుతుంది;
• మ్యాప్ ఖాళీగా ఉంటే boolean isEmpty() ఒప్పు అని, కాకపోతే తప్పు అని చూపుతుంది;
• సెట్ కీసెట్() మ్యాప్ నుండి పొందబడిన కీల సమితిని అందిస్తుంది;
• int size() కీ-వాల్యూ మ్యాపింగ్ పరిమాణాన్ని అందిస్తుంది;
• సేకరణ విలువలు() మ్యాప్ విలువల సేకరణను అందిస్తుంది;
• ఆబ్జెక్ట్ రిమూవ్ (ఆబ్జెక్ట్ కీ) పేర్కొన్న కీ కోసం కీ-విలువ జతని తొలగిస్తుంది;
• void putAll(Map m) మ్యాప్‌లోని అన్ని ఎలిమెంట్‌లను ఇతర మ్యాప్‌కి కాపీ చేస్తుంది.

జావా హాష్ మ్యాప్ ఉదాహరణ

ఇది ఎలా పని చేస్తుందో ప్రదర్శించడానికి Java HashMap ఉదాహరణతో ప్రోగ్రామ్‌ని క్రియేట్ చేద్దాం:

import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;
import java.util.Set;

public class HashMap {

   public static void main(String[] args) {

       {

           // HashMap declaration
           HashMap<Integer, String> myHashMap = new HashMap<Integer, String>();

           //Adding elements into HashMap
           myHashMap.put(7, "Johnny");
           myHashMap.put(8, "Ivy");
           myHashMap.put(1, "Rick");
           myHashMap.put(4, "Stan");
           myHashMap.put(3, "Kyle");

           //print out the map content using Iterator
           Set set = myHashMap.entrySet();
           Iterator iterator = set.iterator();
           while (iterator.hasNext()) {
               Map.Entry mapEntry = (Map.Entry) iterator.next();
               System.out.print("key: " + mapEntry.getKey() + " value: ");
               System.out.println(mapEntry.getValue());
           }
           System.out.println("get an element from myHashMap via key and print the value out:");
           System.out.println(myHashMap.get(8));
           //print out hashMap on standard way:
           System.out.println(myHashMap);

           // Get values based on key
           String var = myHashMap.get(2);
           //here we'll get null, we don't have such a key
           System.out.println("Value with key 2: " + var);
           var = myHashMap.get(7);
           System.out.println("Value with key 7: " + var);

           // Remove values based on key
           myHashMap.remove(4);
           System.out.println("myHashMap after removing element:");
           System.out.println(myHashMap);
           myHashMap.clear();
           System.out.println("myHashMap after total clearing:");
           System.out.println(myHashMap);
       }

   }
}

ప్రోగ్రామ్ అమలు ఫలితంగా:

key: 1 value: Rick
key: 3 value: Kyle
key: 4 value: Stan
key: 7 value: Johnny
key: 8 value: Ivy
get an element from myHashMap via key and print the value out:
Ivy
{1=Rick, 3=Kyle, 4=Stan, 7=Johnny, 8=Ivy}
Value with key 2: null
Value with key 7: Johnny
myHashMap after removing element:
{1=Rick, 3=Kyle, 7=Johnny, 8=Ivy}
myHashMap after total clearing:
{}

ట్రీమ్యాప్

జావాలోని ట్రీమ్యాప్ మ్యాప్<కీ, విలువ> ఇంటర్‌ఫేస్‌ను కూడా అమలు చేస్తుంది, అయితే ఇది రెడ్-బ్లాక్ ట్రీ డేటా స్ట్రక్చర్‌పై ఆధారపడి ఉంటుంది. ఒక చెట్టు "నోడ్లు" మరియు నోడ్లను - శాఖలను కలిపే పంక్తులను కలిగి ఉంటుంది. "రూట్" నోడ్ చెట్టు పైభాగంలో ఉంటుంది. రూట్ నుండి శాఖలు మరియు నోడ్‌లు ఉండవచ్చు. ఇది ఒక క్రమానుగత నిర్మాణం అని మీరు అనుకోవచ్చు. ఈ నోడ్‌లు రూట్ యొక్క "పిల్లలు"గా ఉంటాయి. చైల్డ్ నోడ్ దాని స్వంత పిల్లలను కలిగి ఉంటుంది - దిగువ నోడ్‌లు. పిల్లలు లేని నోడ్‌లను "ఎండ్-నోడ్స్" లేదా "లీవ్స్" అంటారు. బైనరీ ట్రీ ఒక చెట్టు, ఇక్కడ ప్రతి నోడ్‌లో సున్నా ఉంటుంది, ఒకటి , లేదా ఇద్దరు పిల్లలు. బైనరీ సెర్చ్ ట్రీ అనేది ఒక నిర్మాణం, ఇక్కడ ప్రతి అంతర్గత నోడ్ ఒక కీని మరియు కొన్నిసార్లు అనుబంధిత విలువను నిల్వ చేస్తుంది మరియు రెండు విశిష్ట ఉప-వృక్షాలను ("ఎడమ" మరియు "కుడి") కలిగి ఉంటుంది. స్వీయ-బ్యాలెన్సింగ్ బైనరీ సెర్చ్ ట్రీ అనేది నోడ్-ఆధారిత బైనరీ శోధన ట్రీ, ఇది ఏకపక్ష ఐటెమ్ ఇన్‌సర్షన్‌లు మరియు తొలగింపుల నేపథ్యంలో దాని ఎత్తును (రూట్ కంటే తక్కువ స్థాయిల గరిష్ట సంఖ్య) స్వయంచాలకంగా చిన్నగా ఉంచుతుంది. ఎరుపు-నలుపు చెట్టు అనేది లక్షణాలతో కూడిన సమతుల్య బైనరీ చెట్టు:

• ప్రతి నోడ్ ఎరుపు లేదా నలుపు
• మూలం ఎప్పుడూ నల్లగా ఉంటుంది
• ప్రతి ఆకు ఒక NIL (ఖాళీ, శూన్య రకం) నోడ్ మరియు అది నల్లగా ఉంటుంది
• నోడ్ ఎర్రగా ఉంటే, దాని పిల్లలు ఖచ్చితంగా నల్లగా ఉంటారు.
• నోడ్ నుండి అవరోహణ ఆకు వరకు ప్రతి సాధారణ మార్గం అదే సంఖ్యలో బ్లాక్ నోడ్‌లను కలిగి ఉంటుంది.

ట్రీమ్యాప్ ఫీచర్లు

ట్రీమ్యాప్ కీలను నోడ్‌లుగా నిల్వ చేయడానికి ట్రీ డేటా స్ట్రక్చర్‌ను ఉపయోగిస్తుంది మరియు రెడ్-బ్లాక్ ట్రీ అల్గోరిథం ఉపయోగించి కీలను క్రమబద్ధీకరిస్తుంది. కాబట్టి, ట్రీమ్యాప్ దాని ఎంట్రీలను దాని కీల సహజ క్రమం ప్రకారం క్రమబద్ధీకరిస్తుంది. సంఖ్యలకు సహజమైనది ఆరోహణ క్రమం, తీగలకు — అక్షర క్రమం. మీరు ఆర్డరింగ్ యొక్క లాజిక్‌ను మార్చవలసి వస్తే మీరు కంపారిటర్‌ని ఉపయోగించవచ్చు. సహజ పద్ధతిలో వస్తువులను క్రమబద్ధీకరించడం ట్రీమ్యాప్ యొక్క పెద్ద ప్రయోజనం, అలాగే వివిధ ఫిల్టర్‌లు మరియు షరతులను ఉపయోగించి కొన్ని వస్తువులను కనుగొనడం.

ట్రీమ్యాప్ పద్ధతులు

• ఆబ్జెక్ట్ గెట్(ఆబ్జెక్ట్ కీ) సంబంధిత కీ విలువను అందిస్తుంది;
• ఆబ్జెక్ట్ పుట్ (ఆబ్జెక్ట్ కీ, ఆబ్జెక్ట్ విలువ) మ్యాపింగ్‌ను మ్యాప్‌లోకి చొప్పిస్తుంది;
• ఆబ్జెక్ట్ రిమూవ్(ఆబ్జెక్ట్ కీ) ఈ కీ కోసం మ్యాపింగ్‌ను ట్రీమ్యాప్ కలిగి ఉంటే దాన్ని తొలగిస్తుంది;
• ఈ మ్యాప్‌లో పేర్కొన్న కీకి మ్యాపింగ్ ఉంటే boolean containsKey(ఆబ్జెక్ట్ కీ) నిజమని చూపుతుంది;
• ట్రీమ్యాప్ పేర్కొన్న విలువకు ఒకటి లేదా అంతకంటే ఎక్కువ కీలను మ్యాప్ చేస్తే boolean విలువ (ఆబ్జెక్ట్ విలువ) నిజాన్ని అందిస్తుంది;
• Object firstKey() ప్రస్తుతం క్రమబద్ధీకరించబడిన మ్యాప్‌లో ఉన్న మొదటి కీని అందిస్తుంది;
• ఆబ్జెక్ట్ lastKey() ప్రస్తుతం క్రమబద్ధీకరించబడిన మ్యాప్‌లో చివరి కీని అందిస్తుంది;
• void putAll(మ్యాప్ మ్యాప్) పేర్కొన్న మ్యాప్ నుండి మ్యాప్‌కి అన్ని మ్యాపింగ్‌లను కాపీ చేస్తుంది;
• సెట్ ఎంట్రీసెట్() మ్యాపింగ్‌ల సెట్ వీక్షణను అందిస్తుంది
• int size() కీ-విలువ మ్యాపింగ్‌ల పరిమాణాన్ని అందిస్తుంది
• సేకరణ విలువలు() విలువల సేకరణ వీక్షణను అందిస్తుంది
• ఆబ్జెక్ట్ క్లోన్() TreeMap యొక్క నిస్సార కాపీని అందిస్తుంది
• void clear() TreeMap నుండి అన్ని మ్యాపింగ్‌లను తొలగిస్తుంది
• క్రమబద్ధీకరించబడిన మ్యాప్ హెడ్‌మ్యాప్ (ఆబ్జెక్ట్ కీ_విలువ) పరామితి కీ_విలువ కంటే తక్కువ మ్యాప్ భాగం యొక్క వీక్షణను అందిస్తుంది
• సెట్ కీసెట్() ట్రీమ్యాప్‌లో ఉన్న కీల సెట్ వీక్షణను అందిస్తుంది
• క్రమబద్ధీకరించబడిన మ్యాప్ సబ్‌మ్యాప్(K fromKey, K toKey) ఈ మ్యాప్‌లోని భాగపు వీక్షణను అందిస్తుంది, దీని కీలు నుండి కీలు, కలుపుకొని, toKey వరకు, ప్రత్యేకమైనవి
• Object firstKey() TreeMap నుండి మొదటి కీని అందిస్తుంది.

ట్రీమ్యాప్ ఉదాహరణ

import java.util.TreeMap;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;

public class TreeMapExample {

   public static void main(String args[]) {

       //TreeMap declaration
       TreeMap<Integer, String> myTreeMap = new TreeMap<Integer, String>();

       //put elements to TreeMap
       myTreeMap.put(1, "Stuart");
       myTreeMap.put(23, "Michael");
       myTreeMap.put(7, "Johnny");
       myTreeMap.put(5, "Ivy");
       myTreeMap.put(2, "Alex");

       //Display and print out myTreeMap using Iterator
       Set set = myTreeMap.entrySet();
       Iterator iterator = set.iterator();
       while (iterator.hasNext()) {
           Map.Entry myEntry = (Map.Entry) iterator.next();
           System.out.print("key: " + myEntry.getKey() + " value: ");
           System.out.println(myEntry.getValue());
       }
       //TreeMap printed in classical way
       System.out.println(myTreeMap);
       //removing an element with the key =2
       myTreeMap.remove(2);
       //myTreeMap after removing:
       System.out.println(myTreeMap);
   }
}

ప్రోగ్రామ్ అమలు ఫలితంగా:

key: 1 value: Stuart
key: 2 value: Alex
key: 5 value: Ivy
key: 7 value: Johnny
key: 23 value: Michael
{1=Stuart, 2=Alex, 5=Ivy, 7=Johnny, 23=Michael}
{1=Stuart, 5=Ivy, 7=Johnny, 23=Michael}

లింక్డ్ హాష్ మ్యాప్

LinkedHashMap అనేది లింక్ చేయబడిన జాబితాలు మరియు హాష్ మ్యాప్‌లను మిళితం చేసే డేటా నిర్మాణం. నిజానికి, LinkedHashMap HashMap తరగతిని పొడిగిస్తుంది మరియు మ్యాప్ ఇంటర్‌ఫేస్‌ను అమలు చేస్తుంది, అయితే లింక్ చేయబడిన జాబితాల గురించి ఏమిటి? LinkedHashMap యొక్క ప్రకటన:

Map <Integer, String> linkedHashMap = new LinkedHashMap <Integer, String>();

ఈ కొత్త లింక్డ్‌హాష్‌మ్యాప్ HashMap (టేబుల్, లోడ్‌ఫాక్టర్, థ్రెషోల్డ్, సైజు, ఎంట్రీసెట్ వంటివి) నుండి ప్రాపర్టీలను సంక్రమిస్తుంది, రెండు ప్రత్యేక లక్షణాలను కూడా పొందుతుంది:

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

ఈ లింక్ చేయబడిన జాబితా పునరావృత క్రమాన్ని నిర్వచిస్తుంది. సాధారణంగా, ఇది మ్యాప్‌లో కీలను చొప్పించే క్రమం.

లింక్డ్ హాష్ మ్యాప్ పద్ధతులు

• ఆబ్జెక్ట్ గెట్(ఆబ్జెక్ట్ కీ) పేర్కొన్న కీ మ్యాప్ చేయబడిన విలువను అందిస్తుంది లేదా ఈ మ్యాప్‌లో కీకి మ్యాపింగ్ లేనట్లయితే శూన్యం
• void clear() మ్యాప్ నుండి అన్ని మ్యాపింగ్‌లను తొలగిస్తుంది.
• పేర్కొన్న మూలకం ఒకటి లేదా అంతకంటే ఎక్కువ కీల ద్వారా మ్యాప్ చేయబడితే boolean containsKey(ఆబ్జెక్ట్ కీ) నిజాన్ని అందిస్తుంది
• బూలియన్ రిమూవ్ఎల్డెస్ట్‌ఎంట్రీ(మ్యాప్.ఎంట్రీ ఎల్డెస్ట్) మ్యాప్ నుండి దాని ఎల్డెస్ట్ ఎంట్రీని తీసివేస్తే అది నిజం అవుతుంది
• సెట్<Map.Entry<K,V>> entrySet() ఈ మ్యాప్‌లో ఉన్న మ్యాపింగ్‌ల యొక్క సెట్ వీక్షణను అందిస్తుంది
• void forEach(BiConsumer<? super K,? super V> action) ఈ మ్యాప్‌లోని ప్రతి ఎంట్రీకి ఇచ్చిన చర్యను అన్ని ఎంట్రీలు ప్రాసెస్ చేసే వరకు లేదా చర్య మినహాయింపుని ఇచ్చే వరకు చేస్తుంది.
• ఆబ్జెక్ట్ getOrDefault(ఆబ్జెక్ట్ కీ, V డిఫాల్ట్ వాల్యూ) పేర్కొన్న కీ మ్యాప్ చేయబడిన విలువను అందిస్తుంది. మ్యాప్‌లో కీ రిటర్న్స్ డిఫాల్ట్ వాల్యూ కోసం మ్యాపింగ్ లేకపోతే.
• సెట్<K> కీసెట్() మ్యాప్‌లో ఉన్న కీల సెట్ వీక్షణను అందిస్తుంది
• boolean removeEldestEntry(Map.Entry<K,V> eldest) ఈ మ్యాప్ దాని ఎల్డెస్ట్ ఎంట్రీని తీసివేస్తే ఒప్పు అని తిరిగి వస్తుంది
• void replaceAll(BiFunction<? super K,? super V,? పొడిగిస్తుంది V> ఫంక్షన్) అన్ని ఎంట్రీలు ప్రాసెస్ చేయబడే వరకు లేదా ఫంక్షన్ మినహాయింపుని ఇచ్చే వరకు ఆ ఎంట్రీలో ఇచ్చిన ఫంక్షన్‌ను అమలు చేయడం ద్వారా ప్రతి ఎంట్రీ విలువను భర్తీ చేస్తుంది.
• సేకరణ<v>విలువలు() మ్యాప్‌లో ఉన్న విలువల సేకరణ వీక్షణను అందిస్తుంది

లింక్డ్ హాష్ మ్యాప్ ఉదాహరణ

import java.util.LinkedHashMap;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;
   public class HashLinkedListExample {
       public static void main(String args[]) {
           // LinkedHashMap Declaration
           LinkedHashMap<Integer, String> myLinkedHashMap =
                   new LinkedHashMap<Integer, String>();

           //Adding elements into LinkedHashMap
           myLinkedHashMap.put(7, "Johnny");
           myLinkedHashMap.put(12, "Rick");
           myLinkedHashMap.put(1, "Kyle");
           myLinkedHashMap.put(5, "Percy");
           myLinkedHashMap.put(85, "Sebastian");

           // Generate a Set of entries
           Set set = myLinkedHashMap.entrySet();

           // Display and print out the nodes  of LinkedHashMap
           Iterator iterator = set.iterator();
           while(iterator.hasNext()) {
               Map.Entry me = (Map.Entry)iterator.next();
               System.out.print("key: "+ me.getKey() +
                       " value: "+me.getValue()+"\n");
           }
           //print out HashLinkedMap on standard way:
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.put(21, "Ivy");
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.remove(12);
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.put(12, "Ronny");
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.put(1, "Stan");
           System.out.println(myLinkedHashMap);
       }
   }

ఇక్కడ మేము కొత్త లింక్డ్‌హాష్‌మ్యాప్‌ను సృష్టిస్తాము, ఐదు మూలకాలను జోడించి, ఆపై దాన్ని ఇటరేటర్‌ని ఉపయోగించి మరియు క్లాసికల్ పద్ధతిలో ప్రింట్ చేయండి. మీరు చూడగలిగినట్లుగా, LinkedHashMap చొప్పించే క్రమాన్ని నిర్వహిస్తుంది. దాని తర్వాత మేము మా మ్యాప్ నుండి ఒక ఎలిమెంట్‌ను తొలగిస్తాము, ఆపై కొత్తది మరియు తర్వాత - కీతో మరో మూలకం, అది ఇప్పటికే మ్యాప్‌లో ఉంది. ఇది ఈ కీకి మ్యాప్ చేయబడిన పాత విలువను భర్తీ చేస్తుంది. నడుస్తున్న ప్రోగ్రామ్ యొక్క ఫలితం:

key: 7 value: Johnny
key: 12 value: Rick
key: 1 value: Kyle
key: 5 value: Percy
key: 85 value: Sebastian
{7=Johnny, 12=Rick, 1=Kyle, 5=Percy, 85=Sebastian}
{7=Johnny, 12=Rick, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy}
{7=Johnny, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy}
{7=Johnny, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy, 12=Ronny}
{7=Johnny, 1=Stan, 5=Percy, 85=Sebastian, 21=Ivy, 12=Ronny}

HashMap, TreeMap, LinkedHashMap పోలిక

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

• HashMap ఏ క్రమాన్ని నిర్వహించదు.
• TreeMap ఎంట్రీలను కీల ఆరోహణ క్రమంలో క్రమబద్ధీకరిస్తుంది.
• LinkedHashMap చొప్పించే క్రమాన్ని నిర్వహిస్తుంది.

శూన్య కీలు:

• HashMap మరియు LinkedHashMap ఒక శూన్య కీని కలిగి ఉండటానికి అనుమతిస్తుంది.
• లింక్డ్‌హాష్‌మ్యాప్ శూన్య కీలను అనుమతించదు, ఒకవేళ కీలు సహజమైన ఆర్డరింగ్‌ని ఉపయోగిస్తాయి లేదా కంపారిటర్ శూన్య లేపై పోలికకు మద్దతు ఇవ్వదు.

ఈ కథనంలో సమీక్షించబడిన మూడు అమలులను కలిగి ఉన్న జావా మ్యాప్ ఉదాహరణను చూద్దాం:

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.TreeMap;

public class CompMapImpl {


    public static void main(String[] args) {
        HashMap<Integer, String> hashMap = new HashMap<>();
        TreeMap<Integer, String> treeMap = new TreeMap<>();
        LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<>();
        hashMap.put(5, "Ivy");
        hashMap.put(null, "Joker");
        hashMap.put(1, "First");
        hashMap.put(2, "Kyle");
        hashMap.put(-2, "Paul");
        hashMap.put(3, "Sandy");


        treeMap.put(5, "Ivy");
        //treeMap.put(null,"Joker");
        treeMap.put(1, "First");
        treeMap.put(2, "Kyle");
        treeMap.put(-2, "Paul");
        treeMap.put(3, "Sandy");

        linkedHashMap.put(5, "Ivy");
        linkedHashMap.put(null, "Joker");
        linkedHashMap.put(1, "First");
        linkedHashMap.put(2, "Kyle");
        linkedHashMap.put(-2, "Paul");
        linkedHashMap.put(3, "Sandy");
        System.out.println("HashMap");
        System.out.println(hashMap);
        System.out.println("TreeMap");
        System.out.println(treeMap);
        System.out.println("LinkedHashMap");
        System.out.println(linkedHashMap);


        LinkedHashMap<String, String> linkedHashMap1= new LinkedHashMap<> ();
        linkedHashMap1.put(null, "Andy");
        System.out.println(linkedHashMap1);
    }
}

ఈ ప్రోగ్రామ్‌ను అమలు చేయడం వల్ల వచ్చిన ఫలితం ఇక్కడ ఉంది:

HashMap
{null=Joker, 1=First, -2=Paul, 2=Kyle, 3=Sandy, 5=Ivy}
TreeMap
{-2=Paul, 1=First, 2=Kyle, 3=Sandy, 5=Ivy}
LinkedHashMap
{5=Ivy, null=Joker, 1=First, 2=Kyle, -2=Paul, 3=Sandy}
{null=Andy}

మనం చూడగలిగినట్లుగా, HashMapలోని మూలకాల క్రమం స్పష్టంగా లేదు, ట్రీమ్యాప్‌లో ఇది కీలపై ఆధారపడి ఉంటుంది, LinkedHashMapలో ఇది చొప్పించే క్రమం గురించి ఉంటుంది. మేము లింక్డ్‌హాష్‌మ్యాప్‌లో శూన్య కీని ఉంచడానికి ప్రయత్నిస్తే, మేము NullPointerExceptionని పొందుతాము, కానీ లింక్డ్‌హాష్‌మ్యాప్1లో, ఇక్కడ కీలు స్ట్రింగ్‌గా ఉంటాయి, మనం దీన్ని చేయగలము. హాష్ మ్యాప్ అనేది ఉత్తమ సాధారణ-ప్రయోజన మ్యాప్ అమలు. ఇది గరిష్ట శోధన వేగం, వేగవంతమైన నిల్వ మరియు పునరుద్ధరణ కార్యకలాపాలను అందిస్తుంది, అయితే మీరు దాని అస్తవ్యస్తమైన క్రమం గురించి గుర్తుంచుకోవాలి. లింక్ చేయబడిన హాష్ మ్యాప్ HashMap ప్రయోజనాలను పొందుతుంది మరియు కీల కోసం ఆర్డర్‌ను పొందుతుంది. అయినప్పటికీ, ఇది లింక్డ్‌లిస్ట్‌ని కలిగి ఉంది, ఇది మెమరీ పరంగా చాలా ఖరీదైనది. ఇది శోధించడంలో HashMap కంటే నెమ్మదిగా ఉంటుంది మరియు లింక్ చేయబడిన జాబితాను నిర్వహించడం వలన జోడించడానికి/తొలగించడానికి కొంచెం నెమ్మదిగా ఉంటుంది. ట్రీ మ్యాప్ ఆరోహణ క్రమంలో క్రమబద్ధీకరించబడిన కీలను నిల్వ చేస్తుంది. అయితే, మీరు నేర్చుకున్న వాటిని బలోపేతం చేయడానికి, మా జావా కోర్సు నుండి వీడియో పాఠాన్ని చూడమని మేము మీకు సూచిస్తున్నాము