ఈ బ్లాగ్ ఉపయోగం గురించి వివరిస్తుంది ArrayList.contains() ” జావాలో పద్ధతి.
జావాలో “ArrayList.contains()” మెథడ్ అంటే ఏమిటి?
ది ' ArrayList.contains() జావాలో ” అనే పద్ధతి అందించిన జాబితాలో పేర్కొన్న మూలకం ఉందో లేదో తనిఖీ చేయడానికి ఉపయోగించబడుతుంది.
వాక్యనిర్మాణం
ప్రజా బూలియన్ కలిగి ఉంటుంది ( వస్తువు )
పై వాక్యనిర్మాణంలో, “ వస్తువు ” అనేది శోధించవలసిన వస్తువు మూలకాన్ని సూచిస్తుంది.
ఉదాహరణ 1: పూర్ణాంక శ్రేణి జాబితాపై తనిఖీని వర్తింపజేయడానికి “ArrayList.contains()” పద్ధతిని ఉపయోగించడం
ఈ ఉదాహరణలో, ' ArrayList.contains() ” పద్ధతిని అర్రేలిస్ట్‌లో పూర్ణాంకాలను జోడించి, జాబితాలో నిర్దిష్ట పూర్ణాంకం ఉందో లేదో తనిఖీ చేయడానికి ఉపయోగించవచ్చు:
అర్రేలిస్ట్ < పూర్ణ సంఖ్య > numArr = కొత్త అర్రేలిస్ట్ <> ( ) ;
numArr. జోడించు ( 5 ) ;
numArr. జోడించు ( 6 ) ;
numArr. జోడించు ( 7 ) ;
వ్యవస్థ . బయటకు . println ( 'పూర్ణాంక శ్రేణి జాబితా:' + numArr ) ;
వ్యవస్థ . బయటకు . ముద్రణ ( 'అరేలిస్ట్‌లో 5 ఉందా?' ) ;
వ్యవస్థ . బయటకు . println ( numArr. కలిగి ఉంటుంది ( 5 ) ) ;
వ్యవస్థ . బయటకు . ముద్రణ ( '1 అర్రేలిస్ట్‌లో ఉందా?' ) ;
వ్యవస్థ . బయటకు . println ( numArr. కలిగి ఉంటుంది ( 1 ) ) ;
పై కోడ్ స్నిప్పెట్‌లో:
- ముందుగా, కొత్త 'ని సృష్టించండి అర్రేలిస్ట్ పూర్ణాంకాలతో కూడిన వస్తువు.
- తదుపరి దశలో, “ని వర్తింపజేయండి జోడించు() ” అనే పద్ధతిలో పేర్కొన్న పూర్ణాంకాలను దాని(పద్ధతి) పరామితిగా ఒక శ్రేణిలోకి జోడించి దానిని ప్రదర్శించడం.
- ఆ తర్వాత, అనుబంధించండి ' కలిగి () ”అరేలిస్ట్‌లో పేర్కొన్న పూర్ణాంకాలు ఉన్నాయో లేదో తనిఖీ చేయడానికి పేర్కొన్న అర్రేలిస్ట్‌తో పద్ధతి.
- అలా అయితే, పద్ధతి బూలియన్ విలువను అందిస్తుంది ' నిజం ”. లేకపోతే, ' తప్పుడు ” తిరిగి వస్తుంది.
అవుట్‌పుట్
పై అవుట్‌పుట్‌లో, మునుపటి పూర్ణాంకం ''లో ఉన్నట్లు చూడవచ్చు. అర్రేలిస్ట్ ” అయితే రెండో దానిలో అలా కాదు.
ఉదాహరణ 2: “ArrayList.contains()” యొక్క వినియోగం స్ట్రింగ్ అర్రే జాబితాపై తనిఖీని వర్తించే విధానం
ఈ ప్రత్యేక దృష్టాంతంలో, ' ArrayList.contains() 'లో ఉన్న స్ట్రింగ్ కోసం తనిఖీ చేయడానికి ' పద్ధతిని ఉపయోగించవచ్చు అర్రేలిస్ట్ ”:
అర్రేలిస్ట్ < స్ట్రింగ్ > strArr = కొత్త అర్రేలిస్ట్ <> ( ) ;strArr. జోడించు ( 'హ్యారీ' ) ;
strArr. జోడించు ( 'డేవిడ్' ) ;
strArr. జోడించు ( 'ఆల్బర్ట్' ) ;
వ్యవస్థ . బయటకు . println ( 'స్ట్రింగ్ అర్రేలిస్ట్:' + strArr ) ;
వ్యవస్థ . బయటకు . ముద్రణ ( 'జాకబ్ అర్రేలిస్ట్‌లో ఉన్నాడా?' ) ;
వ్యవస్థ . బయటకు . println ( strArr. కలిగి ఉంటుంది ( 'జాకబ్' ) ) ;
వ్యవస్థ . బయటకు . ముద్రణ ( 'అరేలిస్ట్‌లో డేవిడ్ ఉన్నారా?' ) ;
వ్యవస్థ . బయటకు . println ( strArr. కలిగి ఉంటుంది ( 'డేవిడ్' ) ) ;
పై కోడ్ లైన్లలో ఇచ్చిన విధంగా క్రింది దశలను వర్తించండి:
- అదేవిధంగా, కొత్త 'ని సృష్టించడానికి చర్చించిన దశలను గుర్తుచేసుకోండి అర్రేలిస్ట్ ”ఆబ్జెక్ట్ మరియు పేర్కొన్న స్ట్రింగ్ విలువలను జోడించడం.
- ఆ తర్వాత, అనుబంధించండి ' కలిగి () ”అరేలిస్ట్‌లో పేర్కొన్న స్ట్రింగ్‌ల కోసం తనిఖీ చేయడానికి మరియు సంతృప్తి చెందిన మరియు సంతృప్తి చెందని స్థితిలో సంబంధిత బూలియన్ విలువలను ప్రదర్శించడానికి పద్ధతి.
అవుట్‌పుట్
ఉదాహరణ 3: పూర్ణాంకం మరియు స్ట్రింగ్ అర్రేలిస్ట్ విలువలు రెండింటిపై తనిఖీని వర్తింపజేయడానికి “ArrayList.contains()” పద్ధతిని ఉపయోగించడం
ఈ ప్రత్యేక ఉదాహరణలో, అర్రే జాబితా యొక్క పూర్ణాంకం మరియు స్ట్రింగ్ విలువలు రెండింటిపై తనిఖీని వర్తింపజేయడానికి చర్చించబడిన పద్ధతిని అమలు చేయవచ్చు:
అర్రేలిస్ట్ < వస్తువు > strintArr = కొత్త అర్రేలిస్ట్ <> ( ) ;strintArr. జోడించు ( 'హ్యారీ' ) ;
strintArr. జోడించు ( 1 ) ;
strintArr. జోడించు ( 'ఆల్బర్ట్' ) ;
వ్యవస్థ . బయటకు . println ( 'అరేలిస్ట్:' + strintArr ) ;
వ్యవస్థ . బయటకు . ముద్రణ ( '1 అర్రేలిస్ట్‌లో ఉందా?' ) ;
వ్యవస్థ . బయటకు . println ( strintArr. కలిగి ఉంటుంది ( 1 ) ) ;
వ్యవస్థ . బయటకు . ముద్రణ ( 'అరేలిస్ట్‌లో డేవిడ్ ఉన్నారా?' ) ;
వ్యవస్థ . బయటకు . println ( strintArr. కలిగి ఉంటుంది ( 'డేవిడ్' ) ) ;
పై ఉదాహరణలో, ఈ క్రింది దశలను చేయండి:
- అదేవిధంగా, కొత్త 'ని సృష్టించండి అర్రేలిస్ట్ ” వస్తువు.
- గమనించండి' వస్తువు ”అరేలో స్ట్రింగ్ మరియు పూర్ణాంకాల విలువలు రెండింటికి మద్దతు ఇస్తుంది.
- ఆ తర్వాత, పేర్కొన్న స్ట్రింగ్ మరియు పూర్ణాంక విలువలను జోడించడానికి చర్చించిన దశలను పునరావృతం చేయండి ' అర్రేలిస్ట్ ”.
- చివరగా, అర్రేలిస్ట్‌లోని నిర్దిష్ట పూర్ణాంకం మరియు స్ట్రింగ్ విలువలను '' ద్వారా తనిఖీ చేయండి కలిగి () ” పద్ధతి మరియు సంబంధిత అవుట్‌పుట్‌ను తిరిగి ఇవ్వండి.
అవుట్‌పుట్
ఈ అవుట్‌పుట్ కోరుకున్న అవసరం నెరవేరిందని సూచిస్తుంది.
ముగింపు
ది ' ArrayList.contains() 'జావాలోని పద్ధతి అందించిన జాబితాలో పేర్కొన్న మూలకం కలిగి ఉందో లేదో ధృవీకరించడానికి ఉపయోగించబడుతుంది. అనుబంధిత అర్రేలిస్ట్‌లో పూర్ణాంకం మరియు స్ట్రింగ్‌ని తనిఖీ చేయడానికి ఈ పద్ధతిని అన్వయించవచ్చు మరియు సంబంధిత ఫలితాన్ని బూలియన్ విలువ రూపంలో అందిస్తుంది. ఈ వ్యాసం '' యొక్క వినియోగాన్ని వివరించింది. ArrayList.contains() ” జావాలో పద్ధతి.