జావాలో స్టాక్ క్లాస్ అంటే ఏమిటి మరియు దానిని ఎలా ఉపయోగించాలి?

ప్రోగ్రామింగ్ ప్రపంచానికి డేటా స్ట్రక్చర్స్ ఒక వరం. జావాలో స్టాక్ క్లాస్ ఒక భాగం పుష్, పాప్ మొదలైన వివిధ కార్యకలాపాలను సులభతరం చేస్తుంది. ఈ వ్యాసంలో మేము ఈ భావనను వివరంగా అన్వేషిస్తాము. ఈ వ్యాసంలో క్రింది పాయింటర్లు అన్వేషించబడతాయి:

• జావాలో స్టాక్ క్లాస్ అంటే ఏమిటి?
• జావా స్టాక్ క్లాస్‌లో పద్ధతులు
  • • ఖాళీ ()
    • పుష్ ()
    • పాప్ ()
    • పీక్ ()
    • వెతకండి()

• జావా స్టాక్ ఆపరేషన్స్
  • స్టాక్ పరిమాణం
  • ఎలిట్రేట్ ఎలిమెంట్స్
  • జావా స్టాక్ ఉపయోగించి జాబితాను రివర్స్ చేయండి

ప్రారంభిద్దాం.

జావాలో స్టాక్ క్లాస్ అంటే ఏమిటి?

స్టాక్ a డేటా నిర్మాణం ఇది LIFO ను అనుసరిస్తుంది (లాస్ట్ ఇన్ ఫస్ట్ అవుట్). జావా స్టాక్ క్లాస్ ప్రాథమిక కలెక్షన్ హైరార్కీ ఫ్రేమ్‌వర్క్ పరిధిలోకి వస్తుంది, దీనిలో మీరు పుష్, పాప్ మొదలైన ప్రాథమిక కార్యకలాపాలను చేయవచ్చు. మాకు తెలుసుజావా సేకరణ ఫ్రేమ్‌వర్క్‌ను కలిగి ఉంటుంది ఇంటర్ఫేస్లు మరియు తరగతులు . ఇప్పుడు, జావా సేకరణల ఫ్రేమ్‌వర్క్ సోపానక్రమంలో జావాలో స్టాక్ క్లాస్ ఎలా అమర్చబడిందనే దానిపై స్పష్టమైన అభిప్రాయాన్ని కలిగి ఉండండి.

mysql వర్క్‌బెంచ్‌ను ఎలా ఉపయోగించాలి

పై సోపానక్రమంలో, నీలి పెట్టె సూచిస్తుందివిభిన్న ఇంటర్‌ఫేస్‌లు మరియు పసుపు పెట్టె తరగతిని నిర్వచిస్తుంది. జావాలోని ఒక స్టాక్ వెక్టర్ తరగతిని విస్తరిస్తుంది, ఇది మరింత అమలు చేస్తుంది జాబితా ఇంటర్ఫేస్ . మీరు స్టాక్‌ను సృష్టించినప్పుడల్లా, ప్రారంభంలో ఇది ఏ అంశాన్ని కలిగి ఉండదు, అనగా, స్టాక్ ఖాళీగా ఉంటుంది.

ముందుకు వెళుతున్నప్పుడు, జావా స్టాక్ క్లాస్ యొక్క విభిన్న పద్ధతులను చూద్దాం.

జావాలో స్టాక్ క్లాస్ యొక్క పద్ధతులు

జావాలో, స్టాక్ క్లాస్ యొక్క ప్రధానంగా 5 పద్ధతులు ఉన్నాయి.మేము జావాలో స్టాక్ క్లాస్‌ని ఉపయోగించినప్పుడు మన వద్ద ఉన్న పద్ధతులు క్రిందివి.

ప్రోగ్రామాటిక్ ఉదాహరణతో ఈ ప్రతి పద్ధతిని అర్థం చేసుకుందాం:

ప్యాకేజీ ఎడురేకా దిగుమతి java.io. * దిగుమతి java.util. * పబ్లిక్ క్లాస్ స్టాక్‌మెథడ్స్ {// స్టాక్ పైన మూలకాన్ని జోడించండి లేదా నెట్టండి స్టాటిక్ శూన్యమైన పుష్_మెథడ్ (స్టాక్ స్టంప్, పూర్ణాంకం n) {st.push (కొత్త పూర్ణాంకం (n) ) System.out.println ('push (' + n + ')') System.out.println ('ప్రస్తుత స్టాక్:' + st)} // స్టాక్ స్టాటిక్ శూన్య పీక్_మెథోడ్ పైన ఉన్న మూలకాన్ని ప్రదర్శించు (స్టాక్ & ampampampltInteger & ampampampgt st) { పూర్ణాంక మూలకం = (పూర్ణాంకం) st.peek () System.out.println ('స్టాక్ పైభాగంలో మూలకం:' + మూలకం)} // స్టాక్ స్టాటిక్ శూన్య శోధన_మెథడ్ (స్టాక్ స్టంప్, పూర్ణాంక మూలకం) లో మూలకాన్ని శోధిస్తుంది {పూర్ణాంక పోస్ = ( పూర్ణాంకం) st.search (మూలకం) if (pos == -1) System.out.println ('ఎలిమెంట్ కనుగొనబడలేదు') else System.out.println ('ఎలిమెంట్ స్థానం వద్ద కనుగొనబడింది' + pos)} // మూలకాన్ని తొలగిస్తుంది స్టాక్ స్టాటిక్ శూన్యమైన పాప్_మెథోడ్ (స్టాక్ స్టంప్) పై నుండి {System.out.print ('పాప్ =') ఇంటీజర్ n = (ఇంటీజర్) st.pop () System.out.println (n) System.out.println ( 'మిగిలిన స్టాక్:' + స్టంప్)} పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ అర్గ్స్ []) {స్టాక్ స్ట = కొత్త స్టాక్ () సిస్ tem.out.println ('ఖాళీ స్టాక్:' + st) push_method (st, 4) push_method (st, 8) push_method (st, 9) peek_method (st) search_method (st, 2) search_method (st, 4) pop_method ( st) pop_method (st) pop_method (st) ప్రయత్నించండి {pop_method (st)} క్యాచ్ (ఖాళీ స్టాక్ ఎక్సెప్షన్ ఇ) {System.out.println ('ఖాళీ స్టాక్')}}}

అవుట్పుట్:

ఖాళీ స్టాక్: []
పుష్ (4)
ప్రస్తుత స్టాక్: [4]
పుష్ (8)
ప్రస్తుత స్టాక్: [4, 8]
పుష్ (9)
ప్రస్తుత స్టాక్: [4, 8, 9]
స్టాక్ టాప్ పై మూలకం: 9
మూలకం కనుగొనబడలేదు
ఎలిమెంట్ 3 వ స్థానంలో ఉంది
పాప్ = 9
మిగిలిన స్టాక్: [4, 8]
పాప్ = 8
మిగిలిన స్టాక్: [4]
పాప్ = 4
మిగిలిన స్టాక్: []
పాప్ = ఖాళీ స్టాక్

వివరణ: పై వాటిలో , నేను మొదట ఖాళీ స్టాక్‌ను ముద్రించాను మరియు పుష్ పద్ధతిని ఉపయోగించి కొన్ని అంశాలను జోడించాను. మూలకాలు స్టాక్‌లో ఉన్న తర్వాత, నేను పీక్ పద్ధతిని ఉపయోగించి స్టాక్ పైన ఉన్న అంశాలను ప్రదర్శించాను. ఆ తరువాత, నేను శోధన పద్ధతిని ఉపయోగించి శోధనను ప్రదర్శించాను మరియు చివరకు పాప్ పద్ధతిని ఉపయోగించి జావా స్టాక్ తరగతిలోని అంశాలను తొలగించాను.

జావా స్టాక్ క్లాస్‌తో ముందుకు వెళుతున్నప్పుడు, జావాలో స్టాక్ క్లాస్‌ని అమలు చేసేటప్పుడు మీరు చేయగలిగే వివిధ కార్యకలాపాలను చూద్దాం.

జావాలోని ఒక శ్రేణి శ్రేణి

జావా స్టాక్ ఆపరేషన్స్:

స్టాక్ పరిమాణం:

ప్యాకేజీ ఎడురేకా దిగుమతి java.util.EmptyStackException దిగుమతి java.util.Stack పబ్లిక్ క్లాస్ స్టాక్ ఆపరేషన్స్ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {స్టాక్ స్టాక్ = కొత్త స్టాక్ () stack.push ('1') stack.push ('2 ') stack.push (' 3 ') // స్టాక్ ఖాళీగా ఉందో లేదో తనిఖీ చేయండి System.out.println (' జావా స్టాక్ ఖాళీగా ఉందా? '+ stack.isEmpty ()) // స్టాక్ సిస్టమ్.అవుట్ పరిమాణాన్ని కనుగొనండి. println ('స్టాక్ పరిమాణం:' + stack.size ())}}

అవుట్పుట్: జావా స్టాక్ ఖాళీగా ఉందా? తప్పుడు
స్టాక్ పరిమాణం: 3

జావా స్టాక్ యొక్క ఎలిమెంట్ ఎలిమెంట్స్:

• ఇటరేటర్ () ను ఉపయోగించి స్టాక్‌పై మళ్ళించండి
• ప్రతి () కోసం జావా 8 ను ఉపయోగించి స్టాక్‌పై మళ్ళించండి
• ఎగువ నుండి దిగువకు జాబితాఇటరేటర్ () ను ఉపయోగించి స్టాక్‌పై మళ్ళించండి

ఇటరేటర్ () ను ఉపయోగించడం ద్వారా మూలకాలను మళ్ళించడం ప్రారంభిద్దాం.

ప్యాకేజీ ఎడురేకా దిగుమతి java.util.EmptyStackException దిగుమతి java.util.Iterator దిగుమతి java.util.Stack పబ్లిక్ క్లాస్ స్టాక్ ఆపరేషన్స్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {స్టాక్ స్టాక్ = కొత్త స్టాక్ () స్టాక్.పష్ ('1') stack.push ('2') stack.push ('3') Iterator iterator = stack.iterator () అయితే (iterator.hasNext ()) {ఆబ్జెక్ట్ విలువ = iterator.next () System.out.println (విలువ)} }}

అవుట్పుట్:

ఒకటి
2
3

అదేవిధంగా, మీరు ఇతర పద్ధతుల ద్వారా పునరావృతం చేయవచ్చు. మరింత అవగాహన కోసం క్రింది కోడ్‌ను చూడండి:

ప్యాకేజీ డెమో దిగుమతి java.util.EmptyStackException దిగుమతి java.util.Iterator దిగుమతి java.util.ListIterator దిగుమతి java.util.Stack పబ్లిక్ క్లాస్ JavaOperators {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {స్టాక్ స్టాక్ = కొత్త స్టాక్ () స్టాక్. push ('1') stack.push ('2') stack.push ('3') System.out.println ('ప్రతి () విధానం:') ఉపయోగించి స్టాక్‌ను మళ్ళించండి. Stock.forEach (n ->. సిస్టమ్. out.println (n) List) ListIterator ListIterator = stack.listIterator (stack.size ()) System.out.println ('ఎగువ నుండి దిగువకు listIterator () ను ఉపయోగించి స్టాక్‌పై మళ్ళించండి:') అయితే (ListIterator.hasPrevious () ) {స్ట్రింగ్ str = ListIterator.previous () System.out.println (str)}}}

అవుట్పుట్: ప్రతి () పద్ధతిని ఉపయోగించి స్టాక్‌ను మళ్ళించండి:
ఒకటి
2
3
ఎగువ నుండి దిగువకు జాబితాఇటరేటర్ () ను ఉపయోగించి స్టాక్‌పై మళ్ళించండి:
3
2
ఒకటి

జావాలో సీరియలైజబుల్ ఏమిటి

వివరణ: పై కోడ్‌లో, మీరు ప్రతి () పద్ధతిని ఉపయోగించి పునరుక్తిని చూడవచ్చు మరియు ఆపై జాబితా ఎగువ నుండి స్టాక్ పైకి క్రిందికి రివర్స్ చేయవచ్చు.

ఇది “జావాలో స్టాక్ క్లాస్” బ్లాగ్ ముగింపు. జావా సేకరణల ఫ్రేమ్‌వర్క్‌తో మీరు అబ్బాయిలు స్పష్టంగా ఉన్నారని నేను నమ్ముతున్నాను, ఇది సోపానక్రమం జావా స్టాక్ క్లాస్ ఉదాహరణ కోడ్‌లతో పాటు. నా తదుపరి బ్లాగ్ చదవండిపై ఇంటర్వ్యూ ప్రక్రియలో మీరు వేరుచేయడానికి సహాయపడే టాప్ 75 ఇంటర్వ్యూ ప్రశ్నలు మరియు సమాధానాలను నేను జాబితా చేసాను.

ఇప్పుడు మీరు జావా కలెక్షన్స్ అర్థం చేసుకున్నారు, చూడండి ప్రపంచవ్యాప్తంగా విస్తరించి ఉన్న 250,000 మందికి పైగా సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించబడింది. ఈ కోర్సు మీకు జావా ప్రోగ్రామింగ్‌లోకి రావడానికి మరియు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌లతో పాటు కోర్ మరియు అడ్వాన్స్‌డ్ జావా కాన్సెప్ట్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.

మాకు ప్రశ్న ఉందా? దయచేసి ఈ “జావాలోని స్టాక్ క్లాస్” బ్లాగులోని వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.