TechCodeview

ה לַעֲרוֹם הוא מבנה נתונים ליניארי המשמש לאחסון אוסף האובייקטים. זה מבוסס על אחרון נכנס ראשון-אאוט (LIFO). אוסף Java framework מספק ממשקים ומחלקות רבות לאחסון אוסף האובייקטים. אחד מהם הוא ה שיעור מחסנית המספק פעולות שונות כגון דחיפה, פופ, חיפוש וכו'.

בחלק זה, נדון ב שיעור Java Stack , שלה שיטות, ו ליישם מבנה הנתונים מחסנית ב-a תוכנית Java . אבל לפני המעבר למחלקה של Java Stack יש תצוגה מהירה של אופן הפעולה של המחסנית.

למבנה הנתונים מחסנית יש את שתי הפעולות החשובות ביותר שהן לִדחוֹף ו פּוֹפּ . פעולת הדחיפה מכניסה אלמנט לערימה ופעולת פופ מסירה אלמנט מהחלק העליון של הערימה. בוא נראה איך הם עובדים על ערימה.

בואו נדחוף 20, 13, 89, 90, 11, 45, 18, בהתאמה לתוך הערימה.

בוא נסיר (פופ) 18, 45 ו-11 מהערימה.

ערימה ריקה: אם למחסנית אין אלמנט ידוע בתור an מחסנית ריקה . כאשר הערימה ריקה, הערך של המשתנה העליון הוא -1.

כאשר אנו דוחפים אלמנט לתוך הערימה, החלק העליון הוא גדל ב-1 . באיור הבא,

• דחיפה 12, top=0
• דחיפה 6, למעלה=1
• דחף 9, למעלה=2

כאשר אנו קופצים אלמנט מהמחסנית, הערך של top הוא ירד ב-1 . באיור הבא, פרסמנו 9.

java שווה

הטבלה הבאה מציגה את הערכים השונים של החלק העליון.

כיתת ג'אווה מחסנית

ב-Java, לַעֲרוֹם הוא מחלקה הנופלת תחת מסגרת האוסף שמרחיבה את וֶקטוֹר מעמד. זה גם מיישם ממשקים רשימה, אוסף, ניתנת לחזרה, ניתנת לשכפול, ניתנת לסידרה. הוא מייצג את ערימת האובייקטים LIFO. לפני השימוש במחלקה Stack, עלינו לייבא את הjava.utilחֲבִילָה. מחלקת המחסנית מסודרת בהיררכיית המסגרת של אוספים, כפי שמוצג להלן.

בונה כיתת מחסנית

מחלקת Stack מכילה רק את בנאי ברירת מחדל שיוצר ערימה ריקה.

 public Stack() 

יצירת מחסנית

אם ברצוננו ליצור מחסנית, ראשית, ייבא את הjava.utilחבילה וצור אובייקט של המחלקה Stack.

 Stack stk = new Stack(); 

אוֹ

 Stack stk = new Stack(); 

כאשר סוג מציין את סוג המחסנית כמו מספר שלם, מחרוזת וכו'.

שיטות של כיתת מחסנית

אנו יכולים לבצע פעולת דחיפה, פופ, הצצה וחיפוש על הערימה. מחלקת Java Stack מספקת בעיקר חמש שיטות לביצוע פעולות אלו. יחד עם זה, הוא גם מספק את כל השיטות של מחלקה Java Vector .

שיטת Stack Class empty()

ה ריק() שיטה של ​​מחלקת Stack בדוק אם המחסנית ריקה או לא. אם הערימה ריקה, היא מחזירה true, אחרת מחזירה false. אנו יכולים גם להשתמש בשיטת isEmpty() של המחלקה Vector .

תחביר

 public boolean empty() 

החזרות: השיטה מחזירה true אם המחסנית ריקה, אחרת מחזירה false.

בדוגמה הבאה, יצרנו מופע של המחלקה Stack. לאחר מכן, הפעלנו את שיטת ה- empty() פעמיים. בפעם הראשונה זה חוזר נָכוֹן כי לא דחפנו שום אלמנט לערימה. לאחר מכן, דחפנו אלמנטים לערימה. שוב הפעלנו את המתודה () empty שמחזירה שֶׁקֶר כי המחסנית לא ריקה.

StackEmptyMethodExample.java

 import java.util.Stack; public class StackEmptyMethodExample { public static void main(String[] args) { //creating an instance of Stack class Stack stk= new Stack(); // checking stack is empty or not boolean result = stk.empty(); System.out.println('Is the stack empty? ' + result); // pushing elements into stack stk.push(78); stk.push(113); stk.push(90); stk.push(120); //prints elements of the stack System.out.println('Elements in Stack: ' + stk); result = stk.empty(); System.out.println('Is the stack empty? ' + result); } } 

תְפוּקָה:

 Is the stack empty? true Elements in Stack: [78, 113, 90, 120] Is the stack empty? false 

Stack Class שיטת push()

השיטה מכניסה פריט לחלק העליון של הערימה. זה עובד כמו השיטה addElement(item) של המחלקה Vector. זה עובר פרמטר פריט להידחף לערימה.

תחביר

 public E push(E item) 

פָּרָמֶטֶר: פריט שיידחף לחלק העליון של הערימה.

החזרות: השיטה מחזירה את הארגומנט שהעברנו כפרמטר.

Stack Class pop() שיטה

השיטה מסירה אובייקט בחלק העליון של הערימה ומחזירה את אותו אובייקט. זה זורק EmptyStackException אם הערימה ריקה.

תחביר

 public E pop() 

החזרות: זה מחזיר אובייקט שנמצא בראש הערימה.

בואו ליישם את המחסנית בתוכנת Java ונבצע פעולות דחיפה ופופ.

StackPushPopExample.java

 import java.util.*; public class StackPushPopExample { public static void main(String args[]) { //creating an object of Stack class Stack stk = new Stack(); System.out.println('stack: ' + stk); //pushing elements into the stack pushelmnt(stk, 20); pushelmnt(stk, 13); pushelmnt(stk, 89); pushelmnt(stk, 90); pushelmnt(stk, 11); pushelmnt(stk, 45); pushelmnt(stk, 18); //popping elements from the stack popelmnt(stk); popelmnt(stk); //throws exception if the stack is empty try { popelmnt(stk); } catch (EmptyStackException e) { System.out.println('empty stack'); } } //performing push operation static void pushelmnt(Stack stk, int x) { //invoking push() method stk.push(new Integer(x)); System.out.println('push -> ' + x); //prints modified stack System.out.println('stack: ' + stk); } //performing pop operation static void popelmnt(Stack stk) { System.out.print('pop -> '); //invoking pop() method Integer x = (Integer) stk.pop(); System.out.println(x); //prints modified stack System.out.println('stack: ' + stk); } } 

תְפוּקָה:

 stack: [] push -> 20 stack: [20] push -> 13 stack: [20, 13] push -> 89 stack: [20, 13, 89] push -> 90 stack: [20, 13, 89, 90] push -> 11 stack: [20, 13, 89, 90, 11] push -> 45 stack: [20, 13, 89, 90, 11, 45] push -> 18 stack: [20, 13, 89, 90, 11, 45, 18] pop -> 18 stack: [20, 13, 89, 90, 11, 45] pop -> 45 stack: [20, 13, 89, 90, 11] pop -> 11 stack: [20, 13, 89, 90] 

Stack Class peek() שיטת

זה מסתכל על האלמנט שנמצא בחלק העליון בערימה. זה גם זורק EmptyStackException אם הערימה ריקה.

תחביר

 public E peek() 

החזרות: זה מחזיר את הרכיבים העליונים של הערימה.

בוא נראה דוגמה לשיטת peek() .

StackPeekMethodExample.java

 import java.util.Stack; public class StackPeekMethodExample { public static void main(String[] args) { Stack stk= new Stack(); // pushing elements into Stack stk.push('Apple'); stk.push('Grapes'); stk.push('Mango'); stk.push('Orange'); System.out.println('Stack: ' + stk); // Access element from the top of the stack String fruits = stk.peek(); //prints stack System.out.println('Element at top: ' + fruits); } } 

תְפוּקָה:

 Stack: [Apple, Grapes, Mango, Orange] Element at the top of the stack: Orange 

שיטת חיפוש () Stack Class

השיטה מחפשת את האובייקט בערימה מלמעלה. הוא מנתח פרמטר שאנו רוצים לחפש. זה מחזיר את המיקום המבוסס על 1 של האובייקט בערימה. האובייקט העליון של הערימה נחשב במרחק 1.

נניח, o הוא אובייקט בערימה שאנו רוצים לחפש. השיטה מחזירה את המרחק מראש הערימה של ההתרחשות הקרובה ביותר לראש הערימה. זה משתמש שווים() שיטה לחיפוש אובייקט בערימה.

תחביר

 public int search(Object o) 

פָּרָמֶטֶר: o הוא האובייקט הרצוי לחיפוש.

החזרות: זה מחזיר את מיקום האובייקט מהחלק העליון של הערימה. אם הוא מחזיר -1, זה אומר שהאובייקט לא נמצא על הערימה.

בוא נראה דוגמה לשיטת search() .

StackSearchMethodExample.java

 import java.util.Stack; public class StackSearchMethodExample { public static void main(String[] args) { Stack stk= new Stack(); //pushing elements into Stack stk.push('Mac Book'); stk.push('HP'); stk.push('DELL'); stk.push('Asus'); System.out.println('Stack: ' + stk); // Search an element int location = stk.search('HP'); System.out.println('Location of Dell: ' + location); } } 

פעולות Java Stack

גודל הערימה

אנו יכולים גם למצוא את גודל המחסנית באמצעות שיטת size() של המחלקה Vector . הוא מחזיר את המספר הכולל של האלמנטים (גודל הערימה) בערימה.

תחביר

 public int size() 

בוא נראה דוגמה לשיטת size() של המחלקה Vector.

StackSizeExample.java

 import java.util.Stack; public class StackSizeExample { public static void main (String[] args) { Stack stk = new Stack(); stk.push(22); stk.push(33); stk.push(44); stk.push(55); stk.push(66); // Checks the Stack is empty or not boolean rslt=stk.empty(); System.out.println('Is the stack empty or not? ' +rslt); // Find the size of the Stack int x=stk.size(); System.out.println('The stack size is: '+x); } } 

תְפוּקָה:

 Is the stack empty or not? false The stack size is: 5 

איטרט אלמנטים

Iterate פירושו להביא את האלמנטים של המחסנית. אנו יכולים להביא אלמנטים של המחסנית באמצעות שלוש שיטות שונות הן כדלקמן:

• באמצעות iterator() שיטה
• באמצעות לכל אחד() שיטה
• באמצעות listIterator() שיטה

שימוש בשיטת iterator()

זוהי השיטה של ​​ממשק Iterator. זה מחזיר איטרטור מעל האלמנטים בערימה. לפני השימוש בשיטת iterator() ייבא את הjava.util.איטרטורחֲבִילָה.

תחביר

 Iterator iterator() 

בואו נבצע איטרציה על הערימה.

StackIterationExample1.java

 import java.util.Iterator; import java.util.Stack; public class StackIterationExample1 { public static void main (String[] args) { //creating an object of Stack class Stack stk = new Stack(); //pushing elements into stack stk.push('BMW'); stk.push('Audi'); stk.push('Ferrari'); stk.push('Bugatti'); stk.push('Jaguar'); //iteration over the stack Iterator iterator = stk.iterator(); while(iterator.hasNext()) { Object values = iterator.next(); System.out.println(values); } } } 

תְפוּקָה:

 BMW Audi Ferrari Bugatti Jaguar 

שימוש בשיטת forEach()

Java מספקת שיטה forEach() לחזרה על האלמנטים. השיטה מוגדרת ב- ניתן לחזרה ו זרם מִמְשָׁק.

תחביר

מיון מהיר ב-java

 default void forEach(Consumeraction) 

בואו נחזור על המחסנית באמצעות שיטת forEach() .

StackIterationExample2.java

 import java.util.*; public class StackIterationExample2 { public static void main (String[] args) { //creating an instance of Stack class Stack stk = new Stack(); //pushing elements into stack stk.push(119); stk.push(203); stk.push(988); System.out.println('Iteration over the stack using forEach() Method:'); //invoking forEach() method for iteration over the stack stk.forEach(n -> { System.out.println(n); }); } } 

תְפוּקָה:

 Iteration over the stack using forEach() Method: 119 203 988 

שימוש בשיטת listIterator()

שיטה זו מחזירה איטרטור רשימה מעל האלמנטים ברשימה המוזכרת (ברצף), החל מהמיקום שצוין ברשימה. זה חוזר על הערימה מלמעלה למטה.

תחביר

 ListIterator listIterator(int index) 

פָּרָמֶטֶר: השיטה מנתחת פרמטר בשם אינדקס.

החזרות: שיטה זו מחזירה איטרטור רשימה מעל האלמנטים, ברצף.

יוצא מן הכלל: זה זורק IndexOutOfBoundsException אם המדד הוא מחוץ לטווח.

בואו נעבור על המחסנית באמצעות שיטת listIterator() .

StackIterationExample3.java

 import java.util.Iterator; import java.util.ListIterator; import java.util.Stack; public class StackIterationExample3 { public static void main (String[] args) { Stack stk = new Stack(); stk.push(119); stk.push(203); stk.push(988); ListIterator ListIterator = stk.listIterator(stk.size()); System.out.println('Iteration over the Stack from top to bottom:'); while (ListIterator.hasPrevious()) { Integer avg = ListIterator.previous(); System.out.println(avg); } } } 

תְפוּקָה:

 Iteration over the Stack from top to bottom: 988 203 119