ఈ కథనం జావాలో కాన్‌కరెంట్‌హాష్‌మ్యాప్ ఎలిమెంట్‌లను తొలగించి మరియు యాక్సెస్ చేసే విధానాన్ని ప్రదర్శిస్తుంది.
జావాలో కాన్‌కరెంట్ హాష్ మ్యాప్ ఎలిమెంట్స్‌ను ఎలా తొలగించాలి?
నిర్దిష్ట మూలకాలను ' నుండి తీసివేయవచ్చు కాంకరెంట్ హాష్ మ్యాప్ 'మూలకాలు' ద్వారా తొలగించు() ” పద్ధతి. అన్ని మూలకాలను ఒకేసారి తొలగించడానికి, ' స్పష్టమైన () ” పద్ధతి ఎంచుకోవడానికి ఉత్తమ ఎంపిక.
'తొలగించు()' పద్ధతిలో రెండు వైవిధ్యాలు కూడా ఉన్నాయి:
- ది ' తొలగించు (కీ) 'పేర్కొన్న ఎంటిటీని తొలగిస్తుంది' కీ 'ConcurrentHashMap' నుండి.
- ది ' తీసివేయి (కీ, విలువ) 'పేర్కొన్న ఎంటిటీని తొలగిస్తుంది' కీ 'సంబంధిత' వెంట విలువ 'ConcurrentHashMap' నుండి.
మెరుగైన వివరణ కోసం క్రింది కోడ్ బ్లాక్‌ని సందర్శించండి:
దిగుమతి java.util.concurrent.ConcurrentHashMap ;
తరగతి రూట్
{
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) //ప్రధాన () పద్ధతిని సృష్టించడం
{ // ConcurrentHashMap డిక్లరేషన్
కంకరెంట్ హాష్ మ్యాప్ బృందం = కొత్త కాంకరెంట్ హాష్ మ్యాప్ ( ) ;
జట్టు. చాలు ( 'థోర్' , 2 ) ;
జట్టు. చాలు ( 'విచిత్రం' , 4 ) ;
జట్టు. చాలు ( 'హాకీ' , 6 ) ;
వ్యవస్థ . బయటకు . println ( 'కాంకరెంట్ హాష్ మ్యాప్:' + జట్టు ) ;
int విలువ = జట్టు. తొలగించు ( 'విచిత్రం' ) ;
వ్యవస్థ . బయటకు . println ( 'విలువ ' + విలువ + 'తొలగించబడింది' ) ;
వ్యవస్థ . బయటకు . println ( 'కాంకరెంట్ హాష్ మ్యాప్:' + జట్టు ) ;
బూలియన్ ఫలితం = జట్టు. తొలగించు ( 'హాకీ' , 6 ) ;
వ్యవస్థ . బయటకు . println ( 'ఎంట్రీ {హాకీ = 6} తీసివేయబడిందా?' + ఫలితం ) ;
వ్యవస్థ . బయటకు . println ( 'కాంకరెంట్ హాష్ మ్యాప్ నవీకరించబడింది:' + జట్టు ) ;
జట్టు. స్పష్టమైన ( ) ;
వ్యవస్థ . బయటకు . println ( 'కాంకరెంట్ హాష్ మ్యాప్ నవీకరించబడింది:' + జట్టు ) ;
}
}
పై కోడ్ బ్లాక్ యొక్క వివరణ:
- మొదట, 'కన్కరెంట్ హాష్ మ్యాప్' పేరు ' జట్టు ' సృష్టించబడింది, ఆపై డమ్మీ డేటా దానిలో 'ని ఉపయోగించి చొప్పించబడుతుంది చాలు ” పద్ధతి.
- తరువాత, ' తొలగించు() 'పద్ధతి ఉపయోగించబడుతుంది మరియు ' కీ వింత ” అని దానికి పాస్ చేయబడింది. ఈ పద్ధతి 'విచిత్రం' కీని కలిగి ఉన్న మ్యాప్ నుండి ఎంటిటీని తీసివేస్తుంది.
- అదనంగా, 'ConcurrentHashMap' ద్వారా మ్యాప్‌లోని మిగిలిన అంశాలను ప్రదర్శించండి.
- ఇప్పుడు, 'ని పాస్ చేయండి కీ 'మరియు సంబంధిత' విలువ ' కు ' తొలగించు() 'ConcurrentHashMap' నుండి నిర్దిష్ట కీ మరియు విలువను కలిగి ఉన్న ఎంటిటీని తొలగించే పద్ధతి.
- ఆ తర్వాత, తేడాను దృశ్యమానంగా చూడడానికి “ConcurrentHashMap”ని ప్రదర్శించండి.
- చివరికి, 'ని ఉపయోగించండి స్పష్టమైన () 'ConcurrentHashMap' లోపల ఉన్న అన్ని మూలకాలను తొలగించే పద్ధతి. అలాగే, చివరిలో కన్సోల్‌లో “ConcurrentHashMap”ని ప్రదర్శించండి.
సంకలన దశ ముగిసిన తర్వాత:
స్నాప్‌షాట్ ConcurrentHashMap నుండి తీసివేయబడిన మూలకాలను చూపుతుంది.
జావాలో కాన్‌కరెంట్ హాష్ మ్యాప్ ఎలిమెంట్స్‌ను ఎలా యాక్సెస్ చేయాలి?
యొక్క అంశాలు ' కాంకరెంట్ హాష్ మ్యాప్ 'బహుళ సమూహాల పద్ధతులను ఉపయోగించడం ద్వారా యాక్సెస్ చేయవచ్చు. మొదటి సమూహంలో ' ఎంట్రీసెట్() ',' కీసెట్() 'మరియు' విలువలు() ” పద్ధతులు. అన్ని మూలకాలను ఒకేసారి తిరిగి పొందడానికి అవి ఉపయోగించబడతాయి. పై పద్ధతులను ఉపయోగించడం ద్వారా, ప్రోగ్రామర్ అన్నింటినీ తిరిగి పొందేందుకు ఎంచుకోవచ్చు ' కీలు ',' విలువలు ' లేదా రెండూ ' కీ/విలువ ” మ్యాప్ యొక్క మ్యాపింగ్.
పై పద్ధతుల యొక్క ఆచరణాత్మక అమలును అర్థం చేసుకోవడానికి క్రింది కోడ్‌ను సందర్శించండి:
దిగుమతి java.util.concurrent.ConcurrentHashMap ;తరగతి ప్రధాన {
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) //ప్రధాన () పద్ధతిని సృష్టించడం
{ // ConcurrentHashMap డిక్లరేషన్
కంకరెంట్ హాష్ మ్యాప్ బృందం = కొత్త కాంకరెంట్ హాష్ మ్యాప్ ( ) ;
జట్టు. చాలు ( 'థోర్' , 2 ) ;
జట్టు. చాలు ( 'విచిత్రం' , 4 ) ;
జట్టు. చాలు ( 'హాకీ' , 6 ) ;
జట్టు. చాలు ( 'నల్ల చిరుతపులి' , 8 ) ;
వ్యవస్థ . బయటకు . println ( 'కాంకరెంట్ హాష్ మ్యాప్:' + జట్టు ) ;
వ్యవస్థ . బయటకు . println ( 'కీ మరియు విలువలను తిరిగి పొందండి:' + జట్టు. ఎంట్రీసెట్ ( ) ) ;
వ్యవస్థ . బయటకు . println ( 'కీలను తిరిగి పొందండి:' + జట్టు. కీసెట్ ( ) ) ;
వ్యవస్థ . బయటకు . println ( 'విలువలను తిరిగి పొందండి:' + జట్టు. విలువలు ( ) ) ;
}
}
పై కోడ్ బ్లాక్ యొక్క వివరణ:
- ముందుగా, 'ConcurrentHashMap' అనే పేరుని సృష్టించండి జట్టు 'మరియు దానిలో బహుళ మూలకాలను చొప్పించండి' పెట్టు() ” పద్ధతి.
- తర్వాత, కన్సోల్‌లో “ConcurrentHashMap”ని ప్రదర్శించండి out.println() ” పద్ధతి.
- అప్పుడు, 'ని ఉపయోగించండి ఎంట్రీసెట్() ” మ్యాప్‌లో ఉన్న మొత్తం డేటాను తిరిగి పొందే పద్ధతి.
- ఆ తరువాత, 'ని ఉపయోగించండి కీసెట్() ” మ్యాప్ నుండి కీలను మాత్రమే తిరిగి పొందే పద్ధతి.
- చివరికి, 'ని ఉపయోగించండి విలువలు() ” ప్రతి కీతో అనుబంధించబడిన విలువలను మాత్రమే తిరిగి పొందే పద్ధతి. ఇది క్రమంలో విలువలను మాత్రమే అందిస్తుంది.
పై కోడ్ అమలు చేసిన తర్వాత:
ఎగువ స్నాప్‌షాట్‌లో, పైన ఉపయోగించిన పద్ధతుల అవుట్‌పుట్ కన్సోల్‌లో ప్రదర్శించబడుతుంది. మరియు ప్రతి పద్ధతి యొక్క అవుట్‌పుట్ మధ్య దృశ్యమాన విభజనను సృష్టించడానికి వివిధ రంగుల సరిహద్దులు ఉపయోగించబడతాయి.
ఇప్పుడు, రెండవ సమూహంలో ' పొందండి() 'మరియు' getOrDefault() ” పద్ధతులు. ఈ పద్ధతులు తిరిగి పొందడానికి ఉపయోగించబడతాయి ' కీలు ' నుండి ' కాంకరెంట్ హాష్ మ్యాప్ ”. ఉదాహరణకు, దిగువ కోడ్ బ్లాక్‌ని సందర్శించండి:
దిగుమతి java.util.concurrent.ConcurrentHashMap ;తరగతి ప్రధాన {
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) //ప్రధాన () పద్ధతిని సృష్టించడం
{ // ConcurrentHashMap డిక్లరేషన్
కంకరెంట్ హాష్ మ్యాప్ బృందం = కొత్త కాంకరెంట్ హాష్ మ్యాప్ ( ) ;
జట్టు. చాలు ( 'థోర్' , 2 ) ;
జట్టు. చాలు ( 'విచిత్రం' , 4 ) ;
జట్టు. చాలు ( 'హాకీ' , 6 ) ;
జట్టు. చాలు ( 'నల్ల చిరుతపులి' , 8 ) ;
వ్యవస్థ . బయటకు . println ( 'getOrDefault()ని ఉపయోగించడం + విలువ2 ) ;
int విలువ1 = జట్టు. పొందండి ( 'హాకీ' ) ;
వ్యవస్థ . బయటకు . println ( 'నిర్దిష్ట విలువ కోసం తిరిగి పొందబడిన కీ:' + విలువ1 ) ;
int విలువ2 = జట్టు. getOrDefault ( 'రోమనోఫ్' , 10 ) ;
వ్యవస్థ . బయటకు . println ( 'కాంకరెంట్ హాష్ మ్యాప్:' + జట్టు ) ;
}
}
పై కోడ్ యొక్క వివరణ:
- అదే ఉపయోగించుకోండి' కాంకరెంట్ హాష్ మ్యాప్ ” ఇది పై కోడ్ బ్లాక్‌లో సృష్టించబడింది.
- అదనంగా, వర్తించు “ పొందండి() ” పద్ధతి మరియు దాని కుండలీకరణం లోపల కీ తిరిగి పొందబోతున్న విలువను పాస్ చేయండి.
- అంతేకాకుండా, 'ని ఉపయోగించడం getOrDefault() ” రెండు పారామితులు/విలువలు, విలువ మరియు డిఫాల్ట్ కీని తీసుకునే పద్ధతి. మ్యాప్ లోపల పేర్కొన్న వస్తువు కనుగొనబడితే, సంబంధిత కీ తిరిగి పొందబడుతుంది. మరియు పేర్కొన్న విలువ కనుగొనబడకపోతే, డిఫాల్ట్ కీ ఉపయోగించబడుతుంది.
- ఆ తర్వాత, రెండు పద్ధతుల ఫలితాలను వేరియబుల్స్‌లో నిల్వ చేయండి మరియు విజువలైజేషన్ ప్రయోజనాల కోసం వాటిని కన్సోల్‌లో ప్రదర్శించండి.
పై కోడ్ బ్లాక్‌ని అమలు చేసిన తర్వాత:
ఎగువ స్నాప్‌షాట్, కన్సోల్‌లో తిరిగి పొందిన మరియు ముద్రించిన విలువలకు సంబంధించి కీలను ప్రదర్శిస్తుంది.
ముగింపు
' నుండి నిర్దిష్ట మూలకాలను తీసివేయడానికి/తొలగించడానికి కాంకరెంట్ హాష్ మ్యాప్ ' ది ' తొలగించు() ” పద్ధతిని ఉపయోగించవచ్చు. దీన్ని ఉపయోగించడం ద్వారా, ప్రోగ్రామర్ నిర్దిష్ట 'ని కలిగి ఉన్న మూలకాన్ని తొలగించవచ్చు. కీ 'లేదా సంబంధిత' విలువ ”. ఉపయోగంతో ' స్పష్టమైన () ” పద్ధతి, మ్యాప్‌లో ఉన్న ప్రతి మూలకం ఒకేసారి తొలగించబడుతుంది. యాక్సెస్ కోసం, ' ఎంట్రీసెట్() ',' కీసెట్() 'మరియు' విలువలు() ” పద్ధతులు ఉపయోగించబడతాయి. వారు అన్నింటినీ తిరిగి పొందగలరు' కీలు/విలువలు ',' కీలు ', మరియు' విలువలు ' నుండి ' కాంకరెంట్ హాష్ మ్యాప్ ' ఒకేసారి. నిర్దిష్ట కీలను మాత్రమే తిరిగి పొందడానికి, ' పొందండి 'మరియు' getOrDefault ” పద్ధతులు ఉపయోగించబడతాయి.