"మరియు చివరిగా, నేను మీకు మ్యాప్ గురించి చెబుతాను."
"మ్యాప్, మీకు తెలిసినట్లుగా, కీ-విలువ జతల సమితిని నిల్వ చేస్తుంది. కీలు తప్పనిసరిగా ప్రత్యేకంగా ఉండాలి, కానీ విలువలు ఏదైనా కావచ్చు. మీరు మ్యాప్‌కి కీ-విలువ జతని జోడించి, సేకరణలో ఇప్పటికే కీ ఉంటే, అప్పుడు పాత విలువ కొత్త దానితో భర్తీ చేయబడుతుంది. మరో మాటలో చెప్పాలంటే, కీ ఏదైనా వస్తువుగా ఉండే ప్రత్యేక సూచిక వలె పనిచేస్తుంది ."
మ్యాప్ అనేది గణిత పదం, ఇది (x, y) జతల సమితిని సూచిస్తుంది, దీనిలో ప్రతి ప్రత్యేక x కొంత yకి అనుగుణంగా ఉంటుంది.
ప్రోగ్రామర్‌లకు మ్యాప్ అంటే చాలా ఇష్టం, కాబట్టి మ్యాప్ ఇంటర్‌ఫేస్‌ను అమలు చేసే 4 విభిన్న సేకరణలను ఇక్కడ మేము అందిస్తున్నాము:
"దీని సాధారణ వారసత్వ నిర్మాణం ఇక్కడ ఉంది:"
" ఎంట్రీ అనేది మ్యాప్ ఇంటర్‌ఫేస్‌లో ఒక సమూహ ఇంటర్‌ఫేస్ అని పసుపు రంగు సూచిస్తుంది ."
"ఎలిమెంట్ జతను ఒకే ఎంటిటీగా వివరించడానికి ఎంట్రీ జోడించబడింది."
"మ్యాప్<K,V> యొక్క పద్ధతులు ఇక్కడ ఉన్నాయి:"
| పద్ధతులు | వివరణ |
|---|---|
int size() |
మ్యాప్‌లోని జతల సంఖ్యను అందిస్తుంది. |
boolean isEmpty() |
మ్యాప్ ఖాళీగా ఉందో లేదో తనిఖీ చేస్తుంది. |
boolean containsKey(Object key) |
మ్యాప్‌లో పేర్కొన్న కీ ఉందా? |
boolean containsValue(Object value) |
మ్యాప్‌లో పేర్కొన్న విలువ ఉందా? |
V get(Object key) |
పేర్కొన్న కీ కోసం విలువను అందిస్తుంది. |
V put(K key, V value) |
కీ కోసం కొత్త విలువను సెట్ చేస్తుంది. పద్ధతి పాత విలువ లేదా శూన్యతను అందిస్తుంది |
putAll(Map<? extends K, ? extends V> m) |
మరొక మ్యాప్ నుండి జతలను జోడిస్తుంది. |
void clear() |
మ్యాప్‌ను క్లియర్ చేస్తుంది, అంటే అన్ని జతలను తొలగిస్తుంది. |
Set<K>keySet() |
కీల సమితిని అందిస్తుంది. |
Collection<V>values() |
విలువల సేకరణను అందిస్తుంది. |
Set<Map.Entry<K, V>>entrySet() |
జతల సమితిని అందిస్తుంది. |
"K మరియు V అనేది కీలు మరియు విలువల కోసం టైప్ పారామితులు."
"సరే, నాకు చాలా పద్ధతులు బాగా తెలుసు, కానీ నేను వాటిలో కొన్నింటితో మాత్రమే పనిచేశాను."
"ఎంట్రీ క్లాస్ గురించి మీరు ఇంకా ఏమి చెప్పగలరు?"
"ఈ తరగతి ఒక జత మూలకాలను వివరిస్తుంది. దీనికి కొన్ని పద్ధతులు ఉన్నాయి:"
| పద్ధతులు | వివరణ |
|---|---|
K getKey() |
కీ-విలువ జత యొక్క కీని అందిస్తుంది. |
V getValue() |
కీ-విలువ జత విలువను అందిస్తుంది. |
V setValue(V value) |
కీ-విలువ జతలో కొత్త విలువను సెట్ చేస్తుంది. |
"ఎంట్రీ సౌకర్యవంతంగా ఉంటుంది, ఎందుకంటే మీరు మొత్తం మ్యాప్‌ను దాటకుండానే ఒక జతని ఒక పద్ధతికి పంపవచ్చు."
"అలాగా."
"ఇప్పుడు నేను మ్యాప్ అమలులను పరిశీలిస్తాను."
"మొదటది HashMap . ఇది మూలకాలను నిల్వ చేయడానికి హాష్ పట్టికలను ఉపయోగిస్తుంది. కీలు మరియు విలువలు ఏ రకంగానైనా ఉండవచ్చు, అలాగే శూన్యమైనవి. సేకరణ మారినప్పుడు మూలకాల క్రమం మారవచ్చు ."
"ఎలిమెంట్‌లు హ్యాష్‌మ్యాప్‌లో సమూహాలు లేదా బకెట్‌ల సమితిగా నిల్వ చేయబడతాయి. మూలకం యొక్క హ్యాష్‌కోడ్() పద్ధతి అది ఏ బకెట్‌లో పడుతుందో నిర్ణయిస్తుంది."
"చాలా స్థూలంగా చెప్పాలంటే, 1 నుండి 100 వరకు ఉన్న హాష్ కోడ్ ఉన్న మూలకాలు మొదటి బకెట్‌లోకి వస్తాయి, 101 నుండి 200 వరకు విలువ ఉన్నవి రెండవ బకెట్‌లోకి వస్తాయి మరియు మొదలైనవి."
"ఈ విధంగా మూలకాలను నిల్వ చేయడం యొక్క ఉద్దేశ్యం ఏమిటంటే, మూలకాల కోసం శోధిస్తున్నప్పుడు లేదా తీసివేసేటప్పుడు మేము అసంబద్ధమైన బకెట్‌లలోని అన్ని మూలకాలను తొలగించగలము."
"అలాగా."
"HashMap గురించి నిజంగా మంచి కథనం ఉంది. మీరు దీన్ని చదవాలని నేను సిఫార్సు చేస్తున్నాను: https://medium.com/@mr.anmolsehgal/java-hashmap-internal-implementation-21597e1efec3 "
"రెండవ సేకరణ LinkedHashMap . HashMap నుండి దాని ప్రధాన వ్యత్యాసం ఏమిటంటే, ఇది అంశాలను లింక్ చేయబడిన జాబితాగా కూడా నిల్వ చేస్తుంది. సాధారణ HashMapలో, మూలకాల క్రమం నిర్వచించబడలేదు మరియు కాలక్రమేణా మారవచ్చు. మరియు మీరు LinkedHashMap నుండి ఇటరేటర్‌ని పొందవచ్చు. మరియు లింక్డ్‌హాష్‌మ్యాప్‌కు జోడించబడిన క్రమంలో అన్ని మూలకాల ద్వారా నడవడానికి దాన్ని ఉపయోగించండి. అదనంగా, లింక్డ్‌హాష్‌మ్యాప్‌లో ఒక ఇటరేటర్ ఉంది, ఇది చివరి ఉపయోగం/కార్యకలాపం క్రమంలో అన్ని జతల ద్వారా నడవడానికి మిమ్మల్ని అనుమతిస్తుంది."
"LinkedHashMap గురించి మంచి కథనం ఉంది. ఇక్కడ మీరు చూడండి: https://medium.com/@mr.anmolsehgal/java-linkedhashmap-internal-implementation-44e2e2893036 "
"ఈరోజు నేను మాట్లాడాలనుకుంటున్న మూడవ సేకరణ TreeMap ."
" ట్రీమ్యాప్ దాని మూలకాలను ఆరోహణ క్రమంలో క్రమబద్ధీకరిస్తుంది. ఎలిమెంట్‌లను నిల్వ చేయడానికి ట్రీమ్యాప్ సమతుల్య ఎరుపు-నలుపు చెట్టును ఉపయోగిస్తుంది కాబట్టి ఇది సాధించబడుతుంది."
"ఫలితంగా, చొప్పించే సమయం మరియు శోధన సమయం చాలా తక్కువగా ఉన్నాయి. చాలా పెద్ద మొత్తంలో డేటాను ఉపయోగిస్తున్నప్పుడు ఈ తరగతి గొప్ప ఎంపిక."
"మరియు, వాస్తవానికి, మేము TreeMapలో ఒక కథనాన్ని కలిగి ఉన్నాము: https://medium.com/xebia-engineering/treemap-internals-199e0e0050b5 "
"ఇంకా నేను ఏమి చెప్పలేదు?"
"వీక్‌హాష్‌మ్యాప్, కానీ రిషి దాని గురించి రెండు రోజుల క్రితం నాకు చెప్పాడు."
"అది ఎప్పుడు?"
"అతను SoftReference, WeakReference మరియు PhantomReference గురించి మాట్లాడినప్పుడు."
"మీరు వాటన్నిటికీ సరిగ్గా పేరు పెట్టారని నేను నమ్ముతున్నాను. అప్పుడు విశ్రాంతి తీసుకోండి. ఈ రాత్రి కలుద్దాం."
"బై, ఎల్లీ."
GO TO FULL VERSION