जावा स्टॅक

Java मधील स्टॅकचा अर्थ सामान्यतः कलेक्शन फ्रेमवर्कमधील वर्ग आहे जो सूची इंटरफेस लागू करतो. हे स्टॅक डेटा स्ट्रक्चरच्या तत्त्वावर कार्य करते, ज्याचा वापर मेमरीच्या प्रकारांपैकी एक आयोजित करण्यासाठी केला जातो. तसेच डेटा ठेवणे हा मेमरीचा भाग असू शकतो, या लेखात आपण स्टॅक क्लासकडे सर्वप्रथम लक्ष देऊ , त्याच्या पद्धतींचा विचार करू आणि उदाहरणे देऊ. परंतु आम्ही स्टॅकसारख्या डेटा स्ट्रक्चरबद्दल आणि ते कशासाठी वापरले जाते याबद्दल देखील बोलू .

स्टॅक डेटा स्ट्रक्चर म्हणजे काय

सर्वप्रथम, स्टॅक डेटा स्ट्रक्चर म्हणजे काय ते पाहू. ही एक रेखीय डेटा रचना आहे जी लास्ट-इन-फर्स्ट-आउट (LIFO) तत्त्वावर आधारित आहे. हा एक प्रकारचा अँटी-क्यू आहे. एका बॉक्समध्ये कार्डांच्या डेकची किंवा पुस्तकांच्या स्टॅकची कल्पना करा. तुम्ही जे पुस्तक आधी स्टॅकमध्ये ठेवले ते तळाशी आहे, आणि सर्वात आधी आपण बॉक्समधून बाहेर काढू ते सर्वात वरचे पुस्तक आहे - म्हणजे, जे बॉक्समध्ये सर्वात शेवटी आले. हे तत्त्व प्रदर्शित करण्यासाठी येथे एक gif चित्र आहे. इथे काय चालले आहे? आमच्याकडे एक फ्लास्क आहे ज्यामध्ये एका वेळी एकच चेंडू मारता येतो. फ्लास्कमध्ये पहिला नारिंगी बॉल आहे, नंतर जांभळा आणि शेवटी हिरवा (ज्यांना या रंगांची अधिक अचूक नावे माहित आहेत त्यांच्यासाठी मी दिलगीर आहोत). तथापि, आमच्या फ्लास्क-स्टॅकमधून केशरी बॉल काढण्यासाठी, आम्हाला प्रथम तेथे आलेला चेंडू (हिरवा चेंडू) काढावा लागेल, नंतर तो शेवटचा होता (परंतु काढण्याच्या वेळी तो शेवटचा असेल. एक). Java मधील स्टॅक डेटा स्ट्रक्चरमध्ये किंवा इतरत्र प्रोग्रामिंगमध्ये पुश आणि पॉप या दोन सर्वात महत्त्वाच्या ऑपरेशन्स आहेत . पुश ऑपरेशन स्टॅकमध्ये एक घटक घालते आणि पॉप ऑपरेशन स्टॅकच्या शीर्षस्थानी एक घटक काढून टाकते.

स्टॅक डेटा स्ट्रक्चर कशासाठी आहे?

स्टॅकचा सर्वात महत्त्वाचा उपयोग म्हणजे सबरूटीन कॉल्स आयोजित करणे. स्टॅकवरील कॉल पॉइंट सबरूटीन संपल्यानंतर परतीचा पत्ता संग्रहित करतो (आणि शक्यतो पॅरामीटर्स पास). सबरूटीनच्या प्रत्येक नेस्टेड (पुनरावर्तीसह) कॉलसह, नवीन रिटर्न पत्ते स्टॅकमध्ये जोडले जातात. सबरूटीन (रिटर्न) च्या प्रत्येक रिटर्न ऑपरेशनसह, परतीचा पत्ता स्टॅकमधून काढून टाकला जातो आणि त्यावर नियंत्रण हस्तांतरित केले जाते. हे ऍप्लिकेशन प्रोग्रामिंगसाठी इतके महत्त्वाचे आहे की बहुतेक प्रोसेसरमध्ये रिटर्न स्टॅक हार्डवेअरमध्ये इंस्ट्रक्शन सेटमध्ये लागू केला जातो. तथापि, इतर प्रकरणांमध्ये, स्टॅकला अधिक सामान्य डेटा स्ट्रक्चर्सवर मॉडेल केले जावे.

जावा स्टॅक क्लास ऑफ कलेक्शन फ्रेमवर्क

Java मध्ये स्टॅक क्लास हा कलेक्शन फ्रेमवर्कचा एक वर्ग आहे जो लिस्ट इंटरफेस लागू करतो आणि वेक्टर क्लास वाढवतो. हे इंटरफेस कलेक्शन, इटरेबल, क्लोन करण्यायोग्य, सीरियलाइज करण्यायोग्य देखील लागू करते. तुम्ही कदाचित आधीच अंदाज केला असेल की हा वर्ग ऑब्जेक्ट्सच्या LIFO स्टॅकचे प्रतिनिधित्व करतो. येथे स्टॅक क्लासच्या कन्स्ट्रक्टरला कॉल आहे , म्हणजेच या क्लासच्या ऑब्जेक्टची निर्मिती.

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

जेथे ई ऑब्जेक्टचा प्रकार आहे.

जावा स्टॅक पद्धती

या वर्गात फक्त एकच डिफॉल्ट कन्स्ट्रक्टर आणि वेक्टर वर्गाच्या सर्व पद्धती आहेत . तसेच, स्टॅकच्या स्वतःच्या 5 पद्धती आहेत:

• boolean empty() पद्धत स्टॅक रिक्त आहे की नाही हे तपासते. स्टॅक रिकामे असल्यास सत्य मिळवते , नसल्यास असत्य मिळवते.

• ऑब्जेक्ट पीक() पद्धत स्टॅकच्या शीर्षस्थानी असलेला घटक परत करते.

• ऑब्जेक्ट पॉप() पद्धत स्टॅकच्या शीर्षस्थानी असलेला घटक परत करते आणि काढून टाकते.

• ऑब्जेक्ट पुश (ऑब्जेक्ट एलिमेंट) पद्धत स्टॅकच्या शीर्षस्थानी निर्दिष्ट घटक जोडते.

• इंट सर्च (ऑब्जेक्ट एलिमेंट) पद्धत निर्दिष्ट घटकासाठी स्टॅक शोधते. आवश्यक घटक आढळल्यास, वरून त्याचे "अंतर" (अनुक्रमांक) परत केले जाईल. जर घटक सापडला नाही, तर -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() आणि रिमूव्ह() ऑपरेशन्ससाठी मानक देखील आहेत. आमच्या उदाहरणात, add() पद्धत वापरून घटक जोडणे त्याच प्रकारे लागू केले जाऊ शकते . तथापि, तुम्ही फक्त निर्दिष्ट केलेल्या घटकासह remove() वापरून काढू शकता , ज्यामुळे स्टॅक डेटा स्ट्रक्चरला काहीच अर्थ नाही.

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());
           }
       }
   }

कार्यक्रमाच्या कामाचा परिणाम नक्कीच सारखाच असेल.

तुमच्या स्वतःच्या स्टॅक अंमलबजावणीबद्दल काय?

तुम्ही अॅरे किंवा लिंक्ड लिस्ट क्लासेस वापरून Java मध्ये तुमची स्वतःची स्टॅक डेटा स्ट्रक्चर तयार करू शकता. पहिल्या प्रकरणात, मेमरीमध्ये मूल्ये संग्रहित करण्यासाठी सेलची सतत अॅरे वाटप केली जाते, जी आवश्यकतेनुसार वापरली जाते. दुस-यामध्ये, स्टॅकच्या प्रत्येक घटकासाठी, मेमरीचा एक ब्लॉक ऑर्डर केला जातो, जो स्टॅकच्या मागील आणि पुढील घटकांचे मूल्य आणि संदर्भ संग्रहित करण्यासाठी पुरेसा असतो. अ‍ॅरे-आधारित अंमलबजावणी सोपी, अधिक कार्यक्षम आणि अधिक मेमरी कार्यक्षम आहे, परंतु त्यास स्टॅक आकार मर्यादेचे पूर्व ज्ञान आवश्यक आहे आणि यामुळे शोधणे कठीण होऊ शकते. सूची-आधारित अंमलबजावणी अधिक मजबूत परंतु कमी कार्यक्षम आहे. स्टॅकची सोपी अॅरे-आधारित अंमलबजावणी करू. त्यात फंक्शन्सचा समावेश असेल.

• पुश - एक पद्धत जी घटक जोडण्याची खात्री करेल (शीर्ष स्थानावर)

• पॉप - एक पद्धत जी घटक काढून टाकण्याची सुविधा देईल (वरच्या स्थानावरून)

• 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());
       }
   }

}

आउटपुट येथे आहे: आपण बारकाईने पाहिल्यास, शीर्ष व्हेरिएबलमध्ये अंतिम घटकाची अनुक्रमणिका असते आणि ऑब्जेक्टचा संदर्भ अॅरेमध्ये राहतो. त्यामुळे या अंमलबजावणीत काही सुधारणा आवश्यक आहेत. हे करण्याचा सर्वात सोपा मार्ग विचार करा.

आपण Java Stack वापरावे का?

खरं तर, Java स्टॅक , त्याच्या वेक्टर पालकाप्रमाणे, एक वारसा वर्ग आहे. त्याऐवजी, ArrayList वर्ग सहसा वापरला जातो. वेक्टर सिंक्रोनाइझ असताना ArrayList सिंक्रोनाइझ होत नाही . याचा अर्थ व्हेक्टरसह एका वेळी फक्त एक थ्रेड कोडमध्ये प्रवेश करू शकतो, तर ArrayList एकाधिक थ्रेडसह कार्य करू शकते. तसेच, ArrayList अधिक कार्यक्षम आणि जलद आहे. त्यामुळे तुम्हाला बहुधा हा वर्ग फक्त लीगेसी कोडमध्ये दिसेल. परंतु स्टॅक डेटा स्ट्रक्चर प्रोग्रामिंगमध्ये बरेचदा वापरले जाते.