జావా స్టాక్ 101: స్టాక్ క్లాస్‌ని పరిశీలిస్తోంది

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

జావా స్టాక్ క్లాస్‌ని అన్వేషిస్తోంది

జావా స్టాక్ క్లాస్ అనేది వెక్టర్ క్లాస్ యొక్క పొడిగింపు , ఇది జాబితా తరగతిని కూడా విస్తరించింది. వెక్టర్స్ మార్చగలిగేవి మరియు లోపల ఉన్న మూలకాల డిమాండ్‌తో పెరుగుతాయి మరియు కుదించగలవు కాబట్టి, స్టాక్ లు డిమాండ్‌పై పరిమాణాలను కూడా మార్చగలవు. వెక్టర్ క్లాస్ యొక్క పొడిగింపు వెక్టర్‌ను స్టాక్‌గా మార్చే ఐదు కార్యకలాపాలను జోడిస్తుంది . ఈ ఐదు ఆపరేషన్లు:

• .push(E అంశం) – ఒక మూలకాన్ని స్టాక్ పైభాగంలో ఉంచుతుంది
• .pop() – స్టాక్ ఎగువన ఉన్న మూలకాన్ని తీసివేస్తుంది మరియు దానిని ఫంక్షన్ విలువగా అందిస్తుంది
• .peek() – స్టాక్ పైభాగంలో ఉన్న మూలకాన్ని తీసివేయకుండా చూస్తుంది
• .empty() – స్టాక్ ఖాళీగా ఉందో లేదో పరీక్షించడానికి బూలియన్ ఫంక్షన్. 0 లేదా 1ని అందిస్తుంది.
• .search(Object o) - o కోసం వెతుకుతుంది మరియు దాని స్థానాన్ని అందిస్తుంది. విలువ 1-ఆధారితమైనది, 0-ఆధారితమైనది కాదు

స్టాక్ వెక్టర్‌లో భాగమైన అన్ని పద్ధతులను కూడా వారసత్వంగా పొందుతుంది , వీటిలో toString() , కలిగి() , indexOf() , మరియు lastElement() .

జావా స్టాక్ ఉదాహరణ కోడింగ్

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

import java.util.*;

class Main {
  public static void main(String[] args) {
    Stack<Integer> stackExample = new Stack<Integer>();

ఖాళీ స్టాక్‌ని సృష్టించడానికి మీరు చేయాల్సిందల్లా అంతే . మీరు దీన్ని ఉపయోగించి డేటా రకాన్ని ప్రకటించకుండా కేవలం ప్రకటించవచ్చు:

Stack example = new Stack();

స్టాక్‌లు మార్చగలవని గుర్తుంచుకోండి , మేము మూలకాలను స్టాక్‌పైకి నెట్టినప్పుడు, అది స్వయంచాలకంగా పరిమాణంలో సర్దుబాటు అవుతుంది. ఇప్పుడు స్టాక్ ఫంక్షన్లను ఎలా ఉపయోగించాలో చూద్దాం .

జావా స్టాక్ అమలు

ఇంతకు ముందు మనం అన్వేషించిన ఐదు పద్ధతులను ఎలా ఉపయోగించాలో చూద్దాం. మీరు ప్లేట్‌ల స్టాక్‌గా భావిస్తే జావా స్టాక్ అమలును గుర్తుంచుకోవడం సులభం. మీరు ప్లేట్‌లను స్టాక్‌పై ఉంచారు, కానీ ప్లేట్ పొందడానికి, మీరు దిగువకు వెళ్లరు, మీరు పై నుండి ఒకదాన్ని పొందుతారు. మీరు వేసుకున్న చివరిది మీరు తీసే మొదటిది. మా మునుపటి ఉదాహరణను స్టాక్ ఎక్సాంపుల్‌తో విస్తరిస్తే , విధులు క్రింది విధంగా ఉన్నాయి:

పుష్

// pushing integers onto the Stack
    stackExample.push(5);
    stackExample.push(10);

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

పాప్

//popping integers off of the Stack
System.out.println(stackExample.pop());
System.out.println(stackExample.pop());

అవుట్‌పుట్:

10
5

ఖాళీగా ఉంది

ఇప్పుడు, మీరు స్టాక్ నుండి అన్ని ఎలిమెంట్‌లను తీసివేయాలనుకుంటున్నారని చెప్పండి, అయితే ఎన్ని ఎలిమెంట్స్ ఉన్నాయో మీకు ఖచ్చితంగా తెలియదు. స్టాక్ నుండి అన్ని మూలకాలను పాప్ చేయడానికి మీరు Boolean.isEmpty() ఫంక్షన్‌ను ముందస్తు షరతుతో లూప్‌తో కలపవచ్చు . ఈ జావా స్టాక్ అమలు ఎలా జరుగుతుందో చూడండి.

while(!stackExample.isEmpty()) {
  System.out.println(stackExample.pop());
}

అవుట్‌పుట్

10
5

పీక్

జావాలో స్టాక్ అమలుగా .peek()ని ఉపయోగించవచ్చు, దాన్ని తీసివేయకుండా స్టాక్‌లోని తదుపరి అంశాన్ని పరిశీలించవచ్చు .

System.out.println(stackExample.peek());

అవుట్‌పుట్

10

మేము స్టాక్‌ను పాప్ చేసి ప్రింట్ చేస్తే , అది 10 మరియు 5ని అందిస్తుంది ఎందుకంటే 10 ఇప్పటికీ స్టాక్‌లో ఉంది. మేము దానిని చూశాము, మేము దానిని పాప్ ఫంక్షన్‌తో తీసివేయలేదు. జావాలో స్టాక్ s కోసం పీక్ ఫంక్షన్ ఒక గొప్ప సాధనం .

వెతకండి

మేము ఒక నిర్దిష్ట మూలకాన్ని కనుగొనాలనుకుంటే, జావాలోని స్టాక్‌ల అమలు .search(e)ని ఉపయోగిస్తుంది; దానిని కనుగొనడానికి.

System.out.println(stackExample.search(5));

అవుట్‌పుట్

2

మేము స్టాక్ మరియు Java Stack లు 1 నుండి గణించడం వలన ఇది జరుగుతుందని గుర్తుంచుకోండి, అర్రే లాగా 0 కాదు . కాబట్టి, స్టాక్‌ను చూస్తే, అది (10) --> (5), మరియు 5 సంఖ్య 2 స్థానంలో ఉంది. మీరు స్టాక్‌లో లేని మూలకాన్ని కనుగొనడానికి ప్రయత్నిస్తే , మీరు అవుట్‌పుట్‌గా -1ని పొందుతారు.

పునరావృతం

ఏదైనా సేకరణతో పని చేస్తున్నప్పుడు, మీరు బహుళ అంశాల కోసం వెతకాల్సిన సందర్భాలు ఉండవచ్చు. సంక్లిష్టతను సేవ్ చేయడానికి మరియు స్టాక్ ద్వారా అనేకసార్లు శోధించడానికి , మీరు పునరావృతాన్ని ఉపయోగించవచ్చు. జావాలోని స్టాక్ జాబితా తరగతిని విస్తరించినందున , పునరావృతం చేయడానికి అనేక ఎంపికలు ఉన్నాయి. ListIterator ఫంక్షన్‌ను ఉపయోగించడం సులభమయిన వాటిలో ఒకటి . ListIterator బాగుంది, ఇది .hasPrevious() లేదా .hasNext()ని ఉపయోగించి స్టాక్‌ను పై నుండి క్రిందికి లేదా దిగువ నుండి పైకి ప్రయాణించడానికి మిమ్మల్ని అనుమతిస్తుంది . ఇది ఎలా కనిపిస్తుందో ఇక్కడ ఉంది:

ListIterator<Integer> exampleIterator = stackExample.listIterator(stackExample.size());

  while (exampleIterator.hasPrevious()) {
    int iteration = exampleIterator.previous();
    System.out.println(iteration);
  }

అవుట్‌పుట్

10
5

మీరు జావాలో స్టాక్ s ద్వారా మళ్ళించేటప్పుడు, మీరు దానిలోని ఏ మూలకాలను తీసివేయరని గుర్తుంచుకోండి . ఇటరేటింగ్ తప్పనిసరిగా స్టాక్‌లోని ప్రతి మూలకాన్ని క్రమంలో చూడటానికి మిమ్మల్ని అనుమతిస్తుంది. మీరు దీన్ని చేసినప్పుడు, మీరు నిర్దిష్ట మూలకాలు ఉన్న స్థానాల కోసం వెతకవచ్చు మరియు ఆపై వాటిని మార్చవచ్చు. అవసరమైతే మీరు వాటిని లెక్కించవచ్చు, తొలగించవచ్చు లేదా మార్చవచ్చు.