ఈ గైడ్ Javaలో సాధ్యమయ్యే ఉదాహరణలతో పాటు HashSetని వివరిస్తుంది.
జావాలో HashSet ఎలా ఉపయోగించాలి?
జావాలో HashSetని ఉపయోగించడానికి, ముందుగా HashSet తరగతిని దిగుమతి చేయండి. ఆ తర్వాత, HashSet ఆబ్జెక్ట్‌ని సృష్టించండి మరియు 'ని ఉపయోగించి ఎలిమెంట్‌లను జోడించండి జోడించు() ” పద్ధతి. HashSet సభ్యుడిని తొలగించడానికి remove() ఫంక్షన్‌ని ఉపయోగించండి.
HashSetలో మూలకం ఉంటే గణించడానికి వినియోగదారులు కలిగి() పద్ధతిని కూడా ఉపయోగించవచ్చు. చివరగా, HashSetలోని మూలకాలపై మళ్ళించడానికి, ప్రతి లూప్‌ని ఉపయోగించండి.
జావాలో HashSet ఎలా ఉపయోగించాలో ఇక్కడ కొన్ని ఉదాహరణలు ఉన్నాయి:
ఉదాహరణ 1: అర్రేలిస్ట్ నుండి నకిలీలను తీసివేయడం
HashSet కోసం ఒక సాధారణ ఉపయోగ సందర్భం సేకరణ నుండి నకిలీలను తీసివేయడం. ArrayList నుండి నకిలీలను తీసివేయడానికి HashSetని ఎలా ఉపయోగించాలో ఇక్కడ ఒక ఉదాహరణ ఉంది:
దిగుమతి జావా ఉపయోగపడుతుంది . అర్రేలిస్ట్ ;
దిగుమతి జావా ఉపయోగపడుతుంది . HashSet ;
ప్రజా తరగతి తొలగించు డూప్లికేట్స్ ఉదాహరణ {
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
నకిలీలతో అర్రేలిస్ట్ జాబితా = కొత్త అర్రేలిస్ట్ ( ) ;
నకిలీలతో జాబితా. జోడించు ( 'యాపిల్' ) ;
నకిలీలతో జాబితా. జోడించు ( 'అరటి' ) ;
నకిలీలతో జాబితా. జోడించు ( 'నారింజ' ) ;
నకిలీలతో జాబితా. జోడించు ( 'యాపిల్' ) ;
నకిలీలతో జాబితా. జోడించు ( 'నారింజ' ) ;
నకిలీలు లేకుండా HashSet సెట్ = కొత్త HashSet ( నకిలీలతో జాబితా ) ;
నకిలీలు లేని శ్రేణి జాబితా = కొత్త అర్రేలిస్ట్ ( నకిలీలు లేకుండా సెట్ ) ;
వ్యవస్థ. బయటకు . println ( 'నకిలీలతో జాబితా:' + నకిలీలతో జాబితా ) ;
వ్యవస్థ. బయటకు . println ( 'నకిలీలు లేని జాబితా:' + నకిలీలు లేని జాబితా ) ;
}
}
పై కోడ్ యొక్క వివరణ క్రింద ఇవ్వబడింది:
- ముందుగా, నకిలీలతో స్ట్రింగ్‌ల శ్రేణిని సృష్టించండి.
- అప్పుడు, అర్రేలిస్ట్ నుండి హాష్‌సెట్‌ను సృష్టించండి. ఎందుకంటే HashSet ప్రత్యేకమైన అంశాలను మాత్రమే కలిగి ఉంటుంది, ఇది నకిలీలను సమర్థవంతంగా తొలగిస్తుంది.
- చివరగా, నకిలీలు లేకుండా జాబితాను పొందడానికి HashSet నుండి కొత్త ArrayListని సృష్టించండి.
అవుట్‌పుట్
జాబితా నుండి డూప్లికేషన్ తీసివేయబడిందని అవుట్‌పుట్ చూపిస్తుంది.
ఉదాహరణ 2: రెండు సెట్ల మధ్య సాధారణ మూలకాలను కనుగొనడం
HashSet కోసం మరొక ఉపయోగ సందర్భం రెండు సెట్ల మధ్య సాధారణ అంశాలను కనుగొనడం. రెండు సెట్ల మధ్య సాధారణ అంశాలను కనుగొనడానికి HashSet ఎలా ఉపయోగించాలో ఇక్కడ ఒక ఉదాహరణ ఉంది:
ప్రజా తరగతి కామన్ ఎలిమెంట్స్ ఉదాహరణను కనుగొనండి { // తరగతి పేరును పేర్కొనండి
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
HashSet సెట్1 = కొత్త HashSet ( ) ;
సెట్1. జోడించు ( 1 ) ;
సెట్1. జోడించు ( 2 ) ; // ఇక్కడ విలువలను జోడించండి
సెట్1. జోడించు ( 3 ) ;
HashSet సెట్2 = కొత్త HashSet ( ) ;
సెట్2. జోడించు ( 2 ) ;
సెట్2. జోడించు ( 3 ) ; // ఇక్కడ విలువలను జోడించండి
సెట్2. జోడించు ( 4 ) ;
హాష్‌సెట్ కామన్ ఎలిమెంట్స్ = కొత్త HashSet ( సెట్1 ) ;
సాధారణ అంశాలు. అన్నింటినీ నిలుపుకోండి ( సెట్2 ) ;
వ్యవస్థ. బయటకు . println ( 'సెట్ 1:' + సెట్1 ) ;
వ్యవస్థ. బయటకు . println ( 'సెట్ 2:' + సెట్2 ) ;
వ్యవస్థ. బయటకు . println ( 'సాధారణ అంశాలు:' + సాధారణ అంశాలు ) ;
}
}
వివరణ క్రింద ఇవ్వబడింది:
- ముందుగా, రెండు HashSet ఆబ్జెక్ట్‌లను సృష్టించండి మరియు వాటికి కొన్ని పూర్ణాంకాలను జోడించండి.
- తర్వాత, కొత్త HashSet ఆబ్జెక్ట్‌ని సృష్టించండి మరియు set1 నుండి అన్ని ఎలిమెంట్‌లను దానికి జోడించండి.
- ఆ తర్వాత, ఈ కొత్త HashSet ఆబ్జెక్ట్‌పై retainAll() పద్ధతికి కాల్ చేయండి, set2ని ఆర్గ్యుమెంట్‌గా పాస్ చేయండి.
- ఇది కొత్త HashSet నుండి సెట్2లో లేని ఏవైనా ఎలిమెంట్‌లను సమర్థవంతంగా తొలగిస్తుంది, సాధారణ ఎలిమెంట్‌లను మాత్రమే వదిలివేస్తుంది.
అవుట్‌పుట్
రెండు సెట్ల మధ్య సాధారణ అంశాలు కనుగొనబడినట్లు అవుట్‌పుట్ చూపిస్తుంది.
ముగింపు
HashSet అనేది జావాలో ఒక శక్తివంతమైన సేకరణ తరగతి, ఇది నిర్దిష్ట క్రమంలో ప్రత్యేక మూలకాల సమితిని నిల్వ చేయడానికి ఉపయోగించబడుతుంది. ఇది వంటి పద్ధతులను అందిస్తుంది ' జోడించు() ',' తొలగించు() ', మరియు' కలిగి () ” హాష్‌సెట్‌లోని మూలకాల ఉనికిని జోడించడానికి, తీసివేయడానికి మరియు తనిఖీ చేయడానికి. ఇది మూలకాలపై మళ్ళిస్తుంది మరియు ప్రతి లూప్‌తో సరళంగా ఉంటుంది. HashCode() మరియు equals() పద్ధతులను అమలు చేయడం ద్వారా, వినియోగదారులు HashSetలో అనుకూల వస్తువులను కూడా ఉపయోగించవచ్చు.
ఈ గైడ్ జావాలో HashSetని ఉపయోగించడానికి సాధ్యమయ్యే అన్ని ఉదాహరణలను కవర్ చేసింది.