ஜாவா அடுக்கு

ஜாவாவில் அடுக்கு என்பது பொதுவாக பட்டியல் இடைமுகத்தை செயல்படுத்தும் சேகரிப்பு கட்டமைப்பிலிருந்து வரும் வகுப்பைக் குறிக்கிறது. இது ஸ்டாக் தரவு கட்டமைப்பின் கொள்கையின் அடிப்படையில் செயல்படுகிறது, இது நினைவக வகைகளில் ஒன்றை ஒழுங்கமைக்கப் பயன்படுகிறது. தரவுகளை வைத்திருப்பது நினைவகத்தின் ஒரு பகுதியாக இருக்கலாம், இந்த கட்டுரையில் நாம் முதலில் ஸ்டாக் வகுப்பிற்கு கவனம் செலுத்துவோம், அதன் முறைகளைக் கருத்தில் கொண்டு எடுத்துக்காட்டுகளைத் தருவோம். ஆனால் ஸ்டாக் போன்ற தரவு கட்டமைப்பைப் பற்றியும் அது எதற்காகப் பயன்படுத்தப்படுகிறது என்பதைப் பற்றியும் பேசுவோம் .

ஸ்டேக் டேட்டா ஸ்ட்ரக்சர் என்றால் என்ன

முதலில், ஸ்டாக் தரவு அமைப்பு என்றால் என்ன என்பதை விரைவாகப் பார்ப்போம். இது லாஸ்ட்-இன்-ஃபர்ஸ்ட்-அவுட் (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 வகுப்பு பொதுவாக பயன்படுத்தப்படுகிறது. வெக்டார் ஒத்திசைக்கப்படும் போது வரிசைப்பட்டியல் ஒத்திசைக்கப்படவில்லை . அதாவது வெக்டருடன் ஒரே நேரத்தில் ஒரு நூல் மட்டுமே குறியீட்டை அணுக முடியும், அதே சமயம் ArrayList பல நூல்களுடன் வேலை செய்ய முடியும். மேலும், ArrayList மிகவும் திறமையானது மற்றும் வேகமானது. எனவே நீங்கள் பெரும்பாலும் இந்த வகுப்பை மரபுக் குறியீட்டில் மட்டுமே பார்ப்பீர்கள். ஆனால் ஸ்டாக் தரவு அமைப்பு நிரலாக்கத்தில் அடிக்கடி பயன்படுத்தப்படுகிறது.