Java Cadrul de colectare oferă o clasă Stack care modelează și implementează a Diagrama de mai jos arată ierarhia clasei Stack :
Clasa acceptă unul constructor implicit Grămadă() care este obișnuit să creați o stivă goală .
Declaraţie:
public class Stack extends Vector>
Toate interfețele implementate:
- Serializabil: Este o interfață de marcare pe care clasele trebuie să o implementeze dacă urmează să fie serializate și deserializate.
- Clonabil: Aceasta este o interfață în Java care trebuie implementată de o clasă pentru a permite clonarea obiectelor sale.
- Iterabil: Această interfață reprezintă o colecție de obiecte care este iterabilă, adică care poate fi iterată.
- Colectie: O colecție reprezintă un grup de obiecte cunoscut sub numele de elementele sale. Interfața Collection este folosită pentru a trece colecții de obiecte unde se dorește o generalitate maximă.
- Listă: Interfața List oferă o modalitate de a stoca colecția comandată. Este o interfață copil a Collection.
- Acces aleatoriu: Aceasta este o interfață de marcare utilizată de implementările List pentru a indica faptul că acceptă acces aleator rapid (în general în timp constant).
Cum se creează o stivă?
Pentru a crea o stivă, trebuie să importam java.util.stack pachet și utilizați constructorul Stack() al acestei clase. Exemplul de mai jos creează o stivă goală.
Stack stack = new Stack();
Aici E este tipul de obiect.
Exemplu:
Java
// Java code for stack implementation> import> java.io.*;> import> java.util.*;> class> Test> {> >// Pushing element on the top of the stack> >static> void> stack_push(Stack stack)> >{> >for>(>int> i =>0>; i <>5>; i++)> >{> >stack.push(i);> >}> >}> > >// Popping element from the top of the stack> >static> void> stack_pop(Stack stack)> >{> >System.out.println(>'Pop Operation:'>);> >for>(>int> i =>0>; i <>5>; i++)> >{> >Integer y = (Integer) stack.pop();> >System.out.println(y);> >}> >}> >// Displaying element on the top of the stack> >static> void> stack_peek(Stack stack)> >{> >Integer element = (Integer) stack.peek();> >System.out.println(>'Element on stack top: '> + element);> >}> > >// Searching element in the stack> >static> void> stack_search(Stack stack,>int> element)> >{> >Integer pos = (Integer) stack.search(element);> >if>(pos == ->1>)> >System.out.println(>'Element not found'>);> >else> >System.out.println(>'Element is found at position: '> + pos);> >}> >public> static> void> main (String[] args)> >{> >Stack stack =>new> Stack();> >stack_push(stack);> >stack_pop(stack);> >stack_push(stack);> >stack_peek(stack);> >stack_search(stack,>2>);> >stack_search(stack,>6>);> >}> }> |
imprimare python cu 2 zecimale
>
>
Ieșire:
Pop Operation: 4 3 2 1 0 Element on stack top: 4 Element is found at position: 3 Element not found>
Efectuarea diferitelor operații pe clasa Stack
1. Adăugarea de elemente: Pentru a adăuga un element la stivă, putem folosi metoda push(). . Acest Apăsaţi() operațiunea plasați elementul în partea de sus a stivei.
Java
// Java program to add the> // elements in the stack> import> java.io.*;> import> java.util.*;> class> StackDemo {> > >// Main Method> >public> static> void> main(String[] args)> >{> >// Default initialization of Stack> >Stack stack1 =>new> Stack();> >// Initialization of Stack> >// using Generics> >Stack stack2 =>new> Stack();> >// pushing the elements> >stack1.push(>'4'>);> >stack1.push(>'All'>);> >stack1.push(>'Geeks'>);> >stack2.push(>'Geeks'>);> >stack2.push(>'For'>);> >stack2.push(>'Geeks'>);> >// Printing the Stack Elements> >System.out.println(stack1);> >System.out.println(stack2);> >}> }> |
>
>
Ieșire:
[4, All, Geeks] [Geeks, For, Geeks]>
2. Accesarea elementului: Pentru a prelua sau a prelua primul element al Stivei sau elementul prezent în partea de sus a Stivei, putem folosi arunca o privire() metodă. Elementul preluat nu este șters sau eliminat din stivă.
Java
// Java program to demonstrate the accessing> // of the elements from the stack> import> java.util.*;> import> java.io.*;> public> class> StackDemo {> >// Main Method> >public> static> void> main(String args[])> >{> >// Creating an empty Stack> >Stack stack =>new> Stack();> >// Use push() to add elements into the Stack> >stack.push(>'Welcome'>);> >stack.push(>'To'>);> >stack.push(>'Geeks'>);> >stack.push(>'For'>);> >stack.push(>'Geeks'>);> >// Displaying the Stack> >System.out.println(>'Initial Stack: '> + stack);> >// Fetching the element at the head of the Stack> >System.out.println(>'The element at the top of the'> >+>' stack is: '> + stack.peek());> >// Displaying the Stack after the Operation> >System.out.println(>'Final Stack: '> + stack);> >}> }> |
sanjay dutt și
>
>
Ieșire:
Initial Stack: [Welcome, To, Geeks, For, Geeks] The element at the top of the stack is: Geeks Final Stack: [Welcome, To, Geeks, For, Geeks]>
3. Îndepărtarea elementelor: Pentru a scoate un element din stivă, putem folosi pop() metodă. Elementul este scos din partea de sus a stivei și este îndepărtat din același.
Java
// Java program to demonstrate the removing> // of the elements from the stack> import> java.util.*;> import> java.io.*;> public> class> StackDemo {> >public> static> void> main(String args[])> >{> >// Creating an empty Stack> >Stack stack =>new> Stack();> >// Use add() method to add elements> >stack.push(>10>);> >stack.push(>15>);> >stack.push(>30>);> >stack.push(>20>);> >stack.push(>5>);> >// Displaying the Stack> >System.out.println(>'Initial Stack: '> + stack);> >// Removing elements using pop() method> >System.out.println(>'Popped element: '> >+ stack.pop());> >System.out.println(>'Popped element: '> >+ stack.pop());> >// Displaying the Stack after pop operation> >System.out.println(>'Stack after pop operation '> >+ stack);> >}> }> |
>
>
Ieșire:
Initial Stack: [10, 15, 30, 20, 5] Popped element: 5 Popped element: 20 Stack after pop operation [10, 15, 30]>
Exemplu
În Java, clasa Stack este o subclasă a clasei Vector și reprezintă o stivă de obiecte last-in-first-out (LIFO). Extinde clasa Vector pentru a permite implementarea ușoară a structurii de date stive.
Iată un exemplu despre cum puteți utiliza clasa Stack în Java:
Java
import> java.util.Stack;> public> class> StackExample {> >public> static> void> main(String[] args) {> >// Create a new stack> >Stack stack =>new> Stack();> >// Push elements onto the stack> >stack.push(>1>);> >stack.push(>2>);> >stack.push(>3>);> >stack.push(>4>);> >// Pop elements from the stack> >while>(!stack.isEmpty()) {> >System.out.println(stack.pop());> >}> >}> }> |
>
>Ieșire
4 3 2 1>
În acest exemplu, importăm mai întâi clasa Stack din pachetul java.util. Apoi creăm un nou obiect Stack numit stack folosind constructorul implicit. Împingem patru numere întregi în stivă folosind metoda push(). Apoi scoatem elementele din stivă folosind metoda pop() într-o buclă while. Metoda isEmpty() este folosită pentru a verifica dacă stiva este goală înainte de a încerca să pop un element.
Acest cod creează o stivă de numere întregi și împinge 4 numere întregi pe stivă în ordinea 1 -> 2 -> 3 -> 4. Apoi, scoatem elementele din stivă unul câte unul folosind metoda pop(), care elimină și returnează elementul superior al stivei. Deoarece stiva urmează ordinea ultimului intrat, primul ieşit (LIFO), elementele sunt afișate în ordinea inversă inserării, rezultând rezultatul prezentat mai sus.
caseta de listă java
Clasa Stack oferă câteva alte metode de manipulare a stivei, cum ar fi peek() pentru a prelua elementul de sus fără a-l elimina, search() pentru a căuta un element în stivă și a returna poziția acestuia și size() pentru a returna elementul curent. dimensiunea stivei. Clasa Stack oferă, de asemenea, câțiva constructori pentru crearea unei stive cu o capacitate inițială specificată sau prin copierea unei stive existente.
Metode în clasa stivă
| METODĂ | DESCRIERE |
|---|---|
| gol() | Se întoarce adevărat dacă nimic nu este în partea de sus a stivei. Altfel, returnează false. |
| arunca o privire() | Returnează elementul din partea de sus a stivei, dar nu îl elimină. |
| pop() | Îndepărtează și returnează elementul superior al stivei. O „EmptyStackException” O excepție este aruncată dacă apelăm pop() când stiva de invocare este goală. |
| push(element obiect) | Împinge un element în partea de sus a stivei. |
| căutare (element obiect) | Acesta determină dacă un obiect există în stivă. Dacă elementul este găsit, Returnează poziția elementului din partea de sus a stivei. În caz contrar, se întoarce -1. |
Metode moștenite din clasa java.util.Vector
| METODĂ | DESCRIERE |
|---|---|
| adaugă (obiect obiect) | Adaugă elementul specificat la sfârșitul acestui vector. |
| add(int index, Object obj) | Inserează elementul specificat în poziția specificată în acest Vector. |
| addAll(Colecția c) | Adaugă toate elementele din colecția specificată la sfârșitul acestui vector, în ordinea în care sunt returnate de către Iteratorul colecției specificate. |
| addAll(index int, Colecția c) | Inserează toate elementele din Colecția specificată în acest Vector la poziția specificată. |
| addElement(Obiect o) | Adaugă componenta specificată la sfârșitul acestui vector, mărindu-i dimensiunea cu una. |
| capacitate() | Returnează capacitatea curentă a acestui vector. |
| clar() | Îndepărtează toate elementele din acest Vector. |
| clona() | Returnează o clonă a acestui vector. |
| conține (obiectul o) | Returnează adevărat dacă acest vector conține elementul specificat. |
| conţineAll(Colecţia c) | Returnează adevărat dacă acest Vector conține toate elementele din Colecția specificată. |
| copyInto(Obiect []matrice) | Copiază componentele acestui vector în tabloul specificat. |
| elementAt(index int) | Returnează componenta la indexul specificat. |
| elemente() | Returnează o enumerare a componentelor acestui vector. |
| asigurareCapacity(int minCapacity) | Mărește capacitatea acestui vector, dacă este necesar, pentru a se asigura că poate ține cel puțin numărul de componente specificat de argumentul capacității minime. |
| este egal() | Compară obiectul specificat cu acest vector pentru egalitate. |
| firstElement() | Returnează prima componentă (elementul de la indicele 0) a acestui vector. |
| get(index int) | Returnează elementul la poziția specificată în acest Vector. |
| hashCode() | Returnează valoarea codului hash pentru acest vector. |
| indexOf(Obiect o) | Returnează indexul primei apariții a elementului specificat în acest vector sau -1 dacă acest vector nu conţine elementul. |
| indexOf(Obiect o, int index) | Returnează indexul primei apariții a elementului specificat în acest vector, căutând înainte din index sau returnează -1 dacă elementul nu este găsit. |
| insertElementAt(Obiect o, int index) | Inserează obiectul specificat ca componentă în acest vector la indexul specificat. |
| este gol() | Testează dacă acest vector nu are componente. |
| iterator() | Returnează un iterator peste elementele din această listă în ordinea corectă. |
| lastElement() | Returnează ultima componentă a vectorului. |
| lastIndexOf(Obiect o) | Returnează indexul ultimei apariții a elementului specificat în acest vector sau -1 Dacă acest vector nu conţine elementul. |
| lastIndexOf(Obiect o, int index) | Returnează indexul ultimei apariții a elementului specificat în acest vector, căutând înapoi din index sau returnează -1 dacă elementul nu este găsit. |
| listIterator() | Returnează un iterator de listă peste elementele din această listă (în ordinea corectă). |
| listIterator(index int) | Returnează un iterator de listă peste elementele din această listă (în ordinea corectă), începând de la poziția specificată în listă. |
| elimina (index int) | Îndepărtează elementul din poziția specificată în acest Vector. |
| elimina (obiectul o) | Îndepărtează prima apariție a elementului specificat în acest Vector Dacă Vectorul nu conține elementul, acesta este neschimbat. |
| removeAll(Colecția c) | Îndepărtează din acest Vector toate elementele sale care sunt conținute în Colecția specificată. |
| removeAllElements() | Îndepărtează toate componentele din acest vector și setează dimensiunea acestuia la zero. |
| removeElement(Obiect o) | Îndepărtează prima apariție (cel mai jos indexată) a argumentului din acest vector. |
| removeElementAt(index int) | Șterge componenta la indexul specificat. |
| removeRange(int fromIndex, int toIndex) | Elimină din această listă toate elementele al căror index este între fromIndex, inclusiv, și toIndex, exclusiv. |
| retainAll(Colecția c) | Reține numai elementele din acest Vector care sunt conținute în Colecția specificată. |
| set(index int, obiect o) | Înlocuiește elementul din poziția specificată în acest Vector cu elementul specificat. |
| setElementAt(Obiect o, int index) | Setează componenta la indexul specificat al acestui vector să fie obiectul specificat. |
| setSize(int newSize) | Setează dimensiunea acestui vector. |
| mărimea() | Returnează numărul de componente din acest vector. |
| subList(int fromIndex, int toIndex) | Returnează o vizualizare a porțiunii din această listă între fromIndex, inclusiv, și toIndex, exclusiv. |
| toArray() | Returnează o matrice care conține toate elementele din acest Vector în ordinea corectă. |
| toArray(Obiect []matrice) | Returnează o matrice care conține toate elementele din acest Vector în ordinea corectă; timpul de rulare tipul matricei returnate este cel al matricei specificate. |
| toString() | Returnează o reprezentare șir a acestui Vector, care conține reprezentarea șir a fiecărui element. |
| trimToSize() | Decupează capacitatea acestui vector pentru a fi dimensiunea curentă a vectorului. |
Prioritizează utilizarea Despre ce peste stiva -:
Clasa Stack din Java este o clasă moștenită și moștenește de la Vector în Java . Este o clasă sigură pentru fire și, prin urmare, implică supraîncărcare atunci când nu avem nevoie de siguranță pentru fire. Se recomandă utilizarea ArrayDeque pentru implementarea stivei, deoarece este mai eficientă într-un mediu cu un singur thread.
Java
zerouri numpy
// A Java Program to show implementation> // of Stack using ArrayDeque> import> java.util.*;> class> GFG {> >public> static> void> main (String[] args) {> >Deque stack =>new> ArrayDeque();> >stack.push(>'A'>);> >stack.push(>'B'>);> >System.out.println(stack.peek());> >System.out.println(stack.pop());> >}> }> |
>
>
Ieșire:
B B>
Un motiv în plus pentru a utiliza Deque peste Stack este că Deque are capacitatea de a utiliza fluxuri convertite în listă, menținând aplicat conceptul LIFO, în timp ce Stack nu.
Java
import> java.util.*;> import> java.util.stream.Collectors;> class> GFG {> >public> static> void> main (String[] args) {> > >Stack stack =>new> Stack();> >Deque deque =>new> ArrayDeque();> >stack.push(>1>);>//1 is the top> >deque.push(>1>);>//1 is the top> >stack.push(>2>);>//2 is the top> >deque.push(>2>);>//2 is the top> >List list1 = stack.stream().collect(Collectors.toList());>//[1,2]> >System.out.println(>'Using Stack -'>);> >for>(>int> i =>0>; i System.out.print(list1.get(i) + ' ' ); } System.out.println(); List list2 = deque.stream().collect(Collectors.toList());//[2,1] System.out.println('Using Deque -'); for(int i = 0; i System.out.print(list2.get(i) + ' ' ); } System.out.println(); } }> |
>
>Ieșire
Using Stack - 1 2 Using Deque - 2 1>