జావాలో, డెవలపర్ రికార్డుల నుండి పాత లేదా చెత్త విలువలను తీసివేయవలసిన కొన్ని అవసరాలు ఉండవచ్చు. మరింత ప్రత్యేకంగా, కొన్ని నవీకరణ అవసరం లేదా ఉపయోగించని ఎంట్రీల తొలగింపు విషయంలో. అటువంటి సందర్భాలలో, ' Stack.pop() 'పద్ధతి కలిగి ఉన్న చెత్త విలువలను వదిలించుకోవడానికి ప్రభావవంతంగా ఉంటుంది.
ఈ బ్లాగ్ జావాలో “Stack.pop()” పద్ధతిని ఉపయోగించడం మరియు అమలు చేయడం ప్రదర్శిస్తుంది.
జావాలో “Stack.pop()” అంటే ఏమిటి?
జావాలోని స్టాక్ డేటా స్ట్రక్చర్ అనేది “పై ఆధారపడిన సరళ డేటా నిర్మాణం. LIFO (చివరిలో మొదటిది) ” విధానం. దాని ' పాప్() ” జావాలోని పద్ధతి స్టాక్ ఎగువన అందుబాటులో ఉన్న మూలకాన్ని తిరిగి అందిస్తుంది మరియు దానిని స్టాక్ నుండి తీసివేస్తుంది.
వాక్యనిర్మాణం
స్టాక్1.పాప్ ( ) ;
ఈ వాక్యనిర్మాణంలో, ' స్టాక్1 ”ని ఉపయోగించి మూలకాలు పాప్/తొలగించాల్సిన స్టాక్‌కు అనుగుణంగా ఉంటుంది పాప్() ” పద్ధతి.
ఉదాహరణలకు వెళ్లే ముందు, ''తో పని చేయడానికి దిగువ అందించిన ప్యాకేజీని చేర్చారని నిర్ధారించుకోండి. స్టాక్ 'తరగతి:
దిగుమతి java.util.Stack;
ఉదాహరణ 1: జావాలో “Stack.push()” ద్వారా పుష్ చేయబడిన మూలకాలను తొలగించడానికి “Stack.pop()”ని వర్తింపజేయడం
ది ' పుష్() 'ఒక అంశాన్ని నెట్టడానికి లేదా జోడించడానికి' పద్ధతి ఉపయోగించబడుతుంది. స్టాక్ ”. ఈ పద్ధతిని కలిపి ఉపయోగించవచ్చు ' Stack.pop() ”ఎలిమెంట్‌లను స్టాక్‌కి ఇన్సర్ట్ చేసి, ఆపై ఎగువన ఉన్న చివరిగా నెట్టబడిన స్టాక్ ఎలిమెంట్‌ను వరుసగా తీసివేయడం:
పబ్లిక్ క్లాస్ పాప్ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
స్టాక్ < స్ట్రింగ్ > పేర్లు = కొత్త స్టాక్ <> ( ) ;
పేర్లు.పుష్ ( 'జాన్' ) ;
పేర్లు.పుష్ ( 'సారా' ) ;
పేర్లు.పుష్ ( 'డేవిడ్' ) ;
System.out.println ( 'స్టాక్ అవుతుంది:' + పేర్లు ) ;
స్ట్రింగ్ అంశం = names.pop ( ) ;
System.out.println ( 'పాప్ చేయబడిన అంశం:' + అంశం ) ;
System.out.println ( 'కొత్త స్టాక్:' + పేర్లు ) ;
} }
ఎగువ కోడ్ బ్లాక్‌లో, ఈ క్రింది దశలను వర్తించండి:
- అన్నింటిలో మొదటిది, '' ప్రకటించండి స్టాక్ 'మద్దతు' స్ట్రింగ్ 'విలువలు.
- తదుపరి దశలో, అనుబంధించండి ' పుష్() ” పేర్కొన్న స్ట్రింగ్ విలువలను స్టాక్‌కు జోడించి వాటిని ప్రదర్శించడానికి సృష్టించిన స్టాక్‌తో పద్ధతి.
- ఆ తరువాత, వర్తించు ' పాప్() చివరిగా నెట్టబడిన మూలకాన్ని తొలగించే పద్ధతి, అనగా, ' డేవిడ్ ” స్టాక్ నుండి.
- చివరగా, కన్సోల్‌లో పాప్ చేయబడిన ఎలిమెంట్ మరియు అప్‌డేట్ చేయబడిన స్టాక్‌ను వరుసగా ప్రదర్శించండి.
అవుట్‌పుట్
ఈ అవుట్‌పుట్‌లో, మూలకాలు సముచితంగా నెట్టబడి, పాప్ చేయబడడాన్ని గమనించవచ్చు.
ఉదాహరణ 2: జావాలో “Stack.add()” ద్వారా జోడించిన మూలకాలను తొలగించడానికి “Stack.pop()”ని వర్తింపజేయడం
ది ' Stack.add() 'పద్ధతి' కు మూలకాలను జోడిస్తుంది స్టాక్ ”. ఈ పద్ధతిని కలిపి అన్వయించవచ్చు ' Stack.pop() ” స్టాక్ చివరి లేదా ఎగువన జోడించిన పూర్ణాంకాన్ని తొలగించే పద్ధతి.
వాక్యనిర్మాణం
శూన్యమైన యాడ్ ( లో, elem )
ఈ వాక్యనిర్మాణంలో:
- ' లో ” అనేది స్టాక్‌కు పేర్కొన్న మూలకాన్ని తప్పనిసరిగా జోడించాల్సిన సూచికను సూచిస్తుంది.
- ' మూలకం ” స్టాక్‌కు జోడించాల్సిన/అనుబంధించాల్సిన మూలకానికి అనుగుణంగా ఉంటుంది.
ఇప్పుడు, దిగువ అందించిన ఉదాహరణకి వెళ్దాం:
పబ్లిక్ క్లాస్ పాప్ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
స్టాక్ < పూర్ణ సంఖ్య > విలువలు = కొత్త స్టాక్ <> ( ) ;
విలువలు.జోడించు ( 10 ) ;
విలువలు.జోడించు ( ఇరవై ) ;
విలువలు.జోడించు ( 30 ) ;
System.out.println ( 'స్టాక్ అవుతుంది:' + విలువలు ) ;
పూర్ణాంకం అంశం = values.pop ( ) ;
System.out.println ( 'పాప్ చేయబడిన అంశం:' + అంశం ) ;
System.out.println ( 'కొత్త స్టాక్:' + విలువలు ) ;
} }
పై కోడ్ లైన్లలో:
- అదేవిధంగా, 'ని సృష్టించండి స్టాక్ ' యొక్క ' పూర్ణ సంఖ్య ” రకం.
- ఇప్పుడు, అనుబంధిత “ ద్వారా పేర్కొన్న పూర్ణాంక విలువలను జోడించండి జోడించు() ” పద్ధతి.
- తదుపరి దశలో, అదేవిధంగా, వర్తించబడిన “ని ఉపయోగించి చివరిగా జోడించిన పూర్ణాంకాన్ని పాప్ చేయండి పాప్() ” పద్ధతి.
- చివరగా, కన్సోల్‌లో వరుసగా పాప్ చేయబడిన ఎలిమెంట్ మరియు అప్‌డేట్ చేయబడిన స్టాక్‌ను ప్రదర్శించండి.
గమనిక: రెండింటితో కలిసి పనిచేయాల్సిన అవసరం ఉంటే ' పూర్ణ సంఖ్య 'మరియు' స్ట్రింగ్ ''లో డేటా రకాలు స్టాక్ ', ఉపయోగించు' వస్తువు ” బదులుగా టైప్ చేయండి.
అవుట్‌పుట్
ఈ ఫలితంలో, పూర్ణాంకం పాప్ చేయబడిందని మరియు స్టాక్ తగిన విధంగా నవీకరించబడిందని సూచించవచ్చు.
ముగింపు
ది ' Stack.pop() ” జావాలో పద్ధతి స్టాక్ ఎగువన అందుబాటులో ఉన్న మూలకాన్ని తిరిగి అందిస్తుంది మరియు ఆ మూలకాన్ని స్టాక్ నుండి తీసివేస్తుంది. '' ద్వారా నెట్టబడిన మరియు జోడించిన మూలకాలను తొలగించడానికి ఈ పద్ధతిని అన్వయించవచ్చు Stack.push() 'మరియు' Stack.add() ” పద్ధతులు, వరుసగా. ఈ బ్లాగ్ ' యొక్క వినియోగం గురించి చర్చించింది Stack.pop() ” జావాలో పద్ధతి.