జావా స్టాక్

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

స్టాక్ డేటా స్ట్రక్చర్ అంటే ఏమిటి

అన్నింటిలో మొదటిది, స్టాక్ డేటా నిర్మాణం అంటే ఏమిటో శీఘ్రంగా పరిశీలిద్దాం. ఇది లాస్ట్-ఇన్-ఫస్ట్-అవుట్ (LIFO) సూత్రంపై ఆధారపడిన లీనియర్ డేటా స్ట్రక్చర్. ఇది ఒక రకమైన వ్యతిరేక క్యూ. ఒక పెట్టెలో కార్డుల డెక్ లేదా పుస్తకాల స్టాక్‌ను ఊహించుకోండి. మీరు మొదట స్టాక్‌లో ఉంచిన పుస్తకం దిగువన ఉంది మరియు మేము పెట్టెలో నుండి మొదట తీయడం పైన ఉన్న పుస్తకం - అంటే, బాక్స్‌లోకి చివరిగా వచ్చింది. ఈ సూత్రాన్ని ప్రదర్శించడానికి ఇక్కడ gif చిత్రం ఉంది. ఏమి జరుగుతుంది ఇక్కడ? మా వద్ద ఒక ఫ్లాస్క్ ఉంది, దీనిలో ఒకేసారి ఒక బంతి మాత్రమే కొట్టవచ్చు. ఫ్లాస్క్‌లో మొదటిది నారింజ బంతి, తర్వాత ఊదారంగు మరియు చివరగా ఆకుపచ్చ రంగు (ఈ రంగుల యొక్క మరింత ఖచ్చితమైన పేర్లను తెలిసిన వారికి నేను క్షమాపణలు కోరుతున్నాను). అయితే మా ఫ్లాస్క్-స్టాక్ నుండి నారింజ బంతిని తీయడానికి, మనం ముందుగా అక్కడకు చివరిగా వచ్చిన బంతిని (ఆకుపచ్చ రంగు) తీయాలి, ఆపై చివరిది (కానీ వెలికితీసే సమయంలో అది చివరిది). ఒకటి). జావాలో లేదా ప్రోగ్రామింగ్‌లో మరెక్కడైనా స్టాక్ డేటా నిర్మాణం పుష్ మరియు పాప్ అనే రెండు ముఖ్యమైన కార్యకలాపాలను కలిగి ఉంటుంది . పుష్ ఆపరేషన్ స్టాక్‌లోకి ఒక మూలకాన్ని చొప్పిస్తుంది మరియు పాప్ ఆపరేషన్ స్టాక్ పై నుండి ఒక మూలకాన్ని తొలగిస్తుంది.

స్టాక్ డేటా నిర్మాణం దేనికి?

సబ్‌రూటీన్ కాల్‌లను నిర్వహించడం స్టాక్ యొక్క అత్యంత ముఖ్యమైన ఉపయోగాలలో ఒకటి. స్టాక్‌లోని కాల్ పాయింట్ సబ్‌ట్రౌటిన్‌ను ముగించిన తర్వాత దాని నుండి తిరిగి వచ్చే చిరునామాను నిల్వ చేస్తుంది (మరియు బహుశా పారామితులు ఆమోదించబడి ఉండవచ్చు). సబ్‌ట్రౌటీన్‌ల ప్రతి సమూహ (పునరావృతతతో సహా) కాల్‌తో, కొత్త రిటర్న్ చిరునామాలు స్టాక్‌కు జోడించబడతాయి. సబ్‌రూటీన్ (రిటర్న్) నుండి ప్రతి రిటర్న్ ఆపరేషన్‌తో, రిటర్న్ అడ్రస్ స్టాక్ నుండి తీసివేయబడుతుంది మరియు నియంత్రణ దానికి బదిలీ చేయబడుతుంది. ప్రోగ్రామింగ్‌కు ఈ అప్లికేషన్ చాలా ముఖ్యమైనది, చాలా ప్రాసెసర్‌లలో రిటర్న్ స్టాక్ ఇన్‌స్ట్రక్షన్ సెట్‌లోని హార్డ్‌వేర్‌లో అమలు చేయబడుతుంది. అయితే, ఇతర సందర్భాల్లో, స్టాక్ మరింత సాధారణ డేటా నిర్మాణాలపై నమూనాగా ఉండాలి.

జావా స్టాక్ క్లాస్ ఆఫ్ కలెక్షన్ ఫ్రేమ్‌వర్క్

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

Stack<E> stack = new Stack<E>();

ఇక్కడ E అనేది ఆబ్జెక్ట్ రకం.

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

ఈ తరగతికి ఒక డిఫాల్ట్ కన్స్ట్రక్టర్ మరియు వెక్టర్ క్లాస్ యొక్క అన్ని పద్ధతులు మాత్రమే ఉన్నాయి . అదనంగా, స్టాక్ దాని స్వంత 5 పద్ధతులను కలిగి ఉంది:

• బూలియన్ ఖాళీ() పద్ధతి స్టాక్ ఖాళీగా ఉందో లేదో తనిఖీ చేస్తుంది. స్టాక్ ఖాళీగా ఉంటే ఒప్పు , కాకపోతే తప్పు అని చూపుతుంది .

• ఆబ్జెక్ట్ పీక్() పద్ధతి స్టాక్ ఎగువన ఉన్న మూలకాన్ని అందిస్తుంది.

• ఆబ్జెక్ట్ పాప్() పద్ధతి స్టాక్ ఎగువన ఉన్న ఎలిమెంట్‌ను తిరిగి ఇస్తుంది మరియు దానిని తీసివేస్తుంది.

• ఆబ్జెక్ట్ పుష్ (ఆబ్జెక్ట్ ఎలిమెంట్) పద్ధతి పేర్కొన్న మూలకాన్ని స్టాక్ పైభాగానికి జోడిస్తుంది.

• int శోధన (ఆబ్జెక్ట్ మూలకం) పద్ధతి పేర్కొన్న మూలకం కోసం స్టాక్‌ను శోధిస్తుంది. అవసరమైన మూలకం కనుగొనబడితే, ఎగువ నుండి దాని "దూరం" (క్రమ సంఖ్య) తిరిగి ఇవ్వబడుతుంది. మూలకం కనుగొనబడకపోతే, -1 తిరిగి ఇవ్వబడుతుంది.

స్టాక్ కోడ్ ఉదాహరణ

పైన ఉన్న gif చిత్రం వలె పనిచేసే ప్రోగ్రామ్ ఉదాహరణను క్రియేట్ చేద్దాం. మేము స్టాక్‌లో నారింజ, ఊదా మరియు ఆకుపచ్చ మూడు "బంతులను" ఉంచుతాము. శూన్యత కోసం స్టాక్‌ని తనిఖీ చేద్దాం. అప్పుడు, స్టాక్ ఖాళీ అయ్యే వరకు మేము స్టాక్ నుండి బంతులను సంగ్రహిస్తాము.

import java.util.Stack;

public class myStackTest2 {

       public static void main(String[] args)
       {

           Stack myStack= new Stack<>();

           System.out.println("Is my stack empty? " + myStack.empty());
// pushing elements into stack
           myStack.push("Orange Ball");
           myStack.push("Violet Ball");
           myStack.push("Green Ball");

//prints elements of the stack
           System.out.println("Elements in Stack: " + myStack);
           System.out.println("Is my stack empty? " + myStack.empty());
           while (!myStack.isEmpty()) {
               myStack.pop();
               System.out.println("Elements in Stack: " + myStack);
               System.out.println("Is my stack empty? " + myStack.empty());
           }
       }
   }

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

import java.util.Stack;

public class myStackTest2 {

       public static void main(String[] args)
       {

           Stack myStack= new Stack<>();

           System.out.println("Is my stack empty? " + myStack.empty());
// pushing elements into stack
           myStack.add("Orange Ball");
           myStack.add("Violet Ball");
           myStack.add("Green Ball");

//prints elements of the stack
           System.out.println("Elements in Stack: " + myStack);
           System.out.println("Is my stack empty? " + myStack.empty());
           while (!myStack.isEmpty()) {
               myStack.pop();
               System.out.println("Elements in Stack: " + myStack);
               System.out.println("Is my stack empty? " + myStack.empty());
           }
       }
   }

ప్రోగ్రామ్ పని ఫలితం, కోర్సు యొక్క, సరిగ్గా అదే ఉంటుంది.

మీ స్వంత స్టాక్ అమలు గురించి ఏమిటి?

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

• పుష్ - ఒక మూలకం యొక్క జోడింపును నిర్ధారించే పద్ధతి (అగ్ర స్థానంలో)

• పాప్ - ఒక మూలకం యొక్క తొలగింపును అందించే పద్ధతి (అగ్ర స్థానం నుండి)

• readTop — పొజిషన్ టాప్‌లో ఉన్న మూలకం విలువను తిరిగి ఇచ్చే పద్ధతి

• sEmpty — శూన్యత కోసం స్టాక్‌ను తనిఖీ చేసే పద్ధతి

• isFull — మనం స్టాక్‌ను నిల్వ చేసే మా శ్రేణి నిండలేదా అని తనిఖీ చేసే పద్ధతి

import java.util.Arrays;

public class MyStack {

   private int maxSize;
   private String[] stackArray;
   private int top;

   public MyStack(int size) {
       this.maxSize = size;
       stackArray = new String[maxSize];
       top = -1;
   }

   public String push (String element) {
       return stackArray[++top] = element;
      
   }

   public String pop (String element) {

       if (isEmpty())
       {
           System.out.println("Underflow\nProgram Terminated");
           System.exit(-1);
       }

       System.out.println("Removing " + readTop());
      
       return stackArray[top--];

   }

   public String readTop() {
       return stackArray[top];

   }

   public boolean isEmpty() {
       return (top ==  -1);
   }

   public boolean isFull() {
       return (top == maxSize - 1);
   }

   public void printStack(){
       System.out.println(Arrays.toString(stackArray));
   }
}

ఇప్పుడు మన స్టాక్ ఆధారంగా మూడు బంతులతో ఒక ఉదాహరణను అమలు చేద్దాం:

public class myStackTest {
   public static void main(String[] args) {
       MyStack  myStack = new MyStack(3);
       System.out.println("Is my stack empty? " + myStack.isEmpty());

       myStack.push("Orange Ball");
       myStack.push("Violet Ball");
       myStack.push("Green Ball");

      myStack.printStack();

       System.out.println("Is my stack empty? " + myStack.isEmpty());
       while (!myStack.isEmpty()) {
           myStack.pop(myStack.readTop());
           System.out.println("Is my stack empty? " + myStack.isEmpty());
       }
   }

}

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

మనం జావా స్టాక్‌ని ఉపయోగించాలా?

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