Java Marc de la col·lecció proporciona una classe Stack que modela i implementa a El diagrama següent mostra el jerarquia de la classe Stack :
La classe en dóna suport constructor per defecte Stack() que s'acostuma a crear una pila buida .
Declaració:
public class Stack extends Vector>
Totes les interfícies implementades:
- Serialitzable: És una interfície de marcador que les classes han d'implementar si es volen serialitzar i deserialitzar.
- Clonable: Aquesta és una interfície en Java que necessita ser implementada per una classe per permetre que els seus objectes es clonin.
- Iterable: Aquesta interfície representa una col·lecció d'objectes que es poden iterar, és a dir, que es poden iterar.
- Col · lecció: Una col·lecció representa un grup d'objectes coneguts com els seus elements. La interfície Col·lecció s'utilitza per passar col·leccions d'objectes on es desitja la màxima generalitat.
- Llista: La interfície de llista proporciona una manera d'emmagatzemar la col·lecció ordenada. És una interfície fill de Collection.
- Accés aleatori: Aquesta és una interfície de marcador utilitzada per les implementacions de List per indicar que admeten un accés aleatori ràpid (generalment de temps constant).
Com crear una pila?
Per crear una pila, hem d'importar java.util.stack paquet i utilitzeu el constructor Stack() d'aquesta classe. L'exemple següent crea una pila buida.
Stack stack = new Stack();
Aquí E és el tipus d'objecte.
Exemple:
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>);> >}> }> |
string comparar amb java
>
>
Sortida:
Pop Operation: 4 3 2 1 0 Element on stack top: 4 Element is found at position: 3 Element not found>
Realització de diverses operacions a la classe Stack
1. Afegir elements: Per afegir un element a la pila, podem utilitzar el mètode push(). . Això empènyer () L'operació col·loca l'element a la part superior de la pila.
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);> >}> }> |
>
>
Sortida:
[4, All, Geeks] [Geeks, For, Geeks]>
2. Accés a l'element: Per recuperar o recuperar el primer element de la pila o l'element present a la part superior de la pila, podem utilitzar ullada() mètode. L'element recuperat no s'elimina ni s'elimina de la pila.
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);> >}> }> |
conjunt mecanografiat
>
>
Sortida:
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. Eliminació d'elements: Per treure un element de la pila, podem utilitzar el pop() mètode. L'element surt de la part superior de la pila i s'elimina de la mateixa.
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);> >}> }> |
>
>
Sortida:
Initial Stack: [10, 15, 30, 20, 5] Popped element: 5 Popped element: 20 Stack after pop operation [10, 15, 30]>
Exemple
A Java, la classe Stack és una subclasse de la classe Vector i representa una pila d'objectes de l'últim en entrar, primer en sortir (LIFO). Amplia la classe Vector per permetre una fàcil implementació de l'estructura de dades de la pila.
Aquí teniu un exemple de com podeu utilitzar la classe Stack a 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());> >}> >}> }> |
>
>Sortida
escàner java
4 3 2 1>
En aquest exemple, primer importem la classe Stack del paquet java.util. Aleshores creem un nou objecte Stack anomenat stack mitjançant el constructor predeterminat. Introduïm quatre nombres enters a la pila mitjançant el mètode push(). A continuació, extregem els elements de la pila utilitzant el mètode pop() dins d'un bucle while. El mètode isEmpty() s'utilitza per comprovar si la pila està buida abans d'intentar desplegar un element.
Aquest codi crea una pila de nombres enters i empènyer 4 nombres enters a la pila en l'ordre 1 -> 2 -> 3 -> 4. A continuació, esclaten els elements de la pila un a un mitjançant el mètode pop(), que elimina i retorna el element superior de la pila. Com que la pila segueix un ordre d'últim en entrar, primer en sortir (LIFO), els elements apareixen en l'ordre invers d'inserció, donant lloc a la sortida que es mostra a dalt.
La classe Stack proporciona altres mètodes per manipular la pila, com ara peek() per recuperar l'element superior sense eliminar-lo, search() per cercar un element a la pila i retornar la seva posició, i size() per retornar l'actual. mida de la pila. La classe Stack també proporciona diversos constructors per crear una pila amb una capacitat inicial especificada o per copiar una pila existent.
Mètodes a la classe Stack
| MÈTODE | DESCRIPCIÓ |
|---|---|
| buit() | Torna veritable si no hi ha res a la part superior de la pila. En cas contrari, retorna fals. |
| ullada() | Retorna l'element a la part superior de la pila, però no l'elimina. |
| pop() | Elimina i torna l'element superior de la pila. Una 'EmptyStackException' Es llança una excepció si cridem pop() quan la pila d'invocació està buida. |
| push (element objecte) | Empeny un element a la part superior de la pila. |
| cerca (element objecte) | Determina si existeix un objecte a la pila. Si es troba l'element, Retorna la posició de l'element des de la part superior de la pila. En cas contrari, retorna -1. |
Mètodes heretats de la classe java.util.Vector
| MÈTODE | DESCRIPCIÓ |
|---|---|
| afegir (objecte objecte) | Afegeix l'element especificat al final d'aquest vector. |
| afegir (índex int, object obj) | Insereix l'element especificat a la posició especificada en aquest vector. |
| addAll(Col·lecció c) | Afegeix tots els elements de la col·lecció especificada al final d'aquest vector, en l'ordre en què són retornats per l'iterador de la col·lecció especificat. |
| addAll(índex int, col·lecció c) | Insereix tots els elements de la col·lecció especificada en aquest vector a la posició especificada. |
| addElement(Objecte o) | Afegeix el component especificat al final d'aquest vector, augmentant la seva mida en un. |
| capacitat () | Retorna la capacitat actual d'aquest vector. |
| clar () | Elimina tots els elements d'aquest vector. |
| clonar () | Retorna un clon d'aquest vector. |
| conté (Objecte o) | Retorna true si aquest vector conté l'element especificat. |
| contéAll(Col·lecció c) | Retorna true si aquest vector conté tots els elements de la col·lecció especificada. |
| copyInto(Objecte []matriu) | Copia els components d'aquest vector a la matriu especificada. |
| elementAt (índex int) | Retorna el component a l'índex especificat. |
| elements () | Retorna una enumeració dels components d'aquest vector. |
| garantirCapacitat(int minCapacity) | Augmenta la capacitat d'aquest vector, si cal, per assegurar-se que pot contenir almenys el nombre de components especificat per l'argument de capacitat mínima. |
| és igual() | Compara l'objecte especificat amb aquest vector per a la igualtat. |
| firstElement() | Retorna el primer component (l'element de l'índex 0) d'aquest vector. |
| obtenir (índex int) | Retorna l'element a la posició especificada en aquest vector. |
| hashCode() | Retorna el valor del codi hash per a aquest vector. |
| indexOf(Objecte o) | Retorna l'índex de la primera ocurrència de l'element especificat en aquest vector, o bé -1 si aquest vector no conté l'element. |
| indexOf(Objecte o, int índex) | Retorna l'índex de la primera ocurrència de l'element especificat en aquest vector, cerca cap endavant des de l'índex, o retorna -1 si no es troba l'element. |
| insertElementAt(Objecte o, índex int) | Insereix l'objecte especificat com a component en aquest vector a l'índex especificat. |
| està buit() | Comprova si aquest vector no té components. |
| iterador() | Retorna un iterador sobre els elements d'aquesta llista en la seqüència adequada. |
| lastElement() | Retorna l'últim component del vector. |
| lastIndexOf(Objecte o) | Retorna l'índex de l'última ocurrència de l'element especificat en aquest vector, o bé -1 Si aquest vector no conté l'element. |
| lastIndexOf(Objecte o, índex int) | Retorna l'índex de l'última ocurrència de l'element especificat en aquest vector, cerca cap enrere des de l'índex, o retorna -1 si no es troba l'element. |
| listIterator() | Retorna un iterador de llista sobre els elements d'aquesta llista (en la seqüència adequada). |
| listIterator (índex int) | Retorna un iterador de llista sobre els elements d'aquesta llista (en la seqüència adequada), començant a la posició especificada a la llista. |
| eliminar (índex int) | Elimina l'element a la posició especificada en aquest vector. |
| eliminar (Objecte o) | Elimina la primera ocurrència de l'element especificat en aquest vector Si el vector no conté l'element, no es modifica. |
| removeAll(Col·lecció c) | Elimina d'aquest Vector tots els seus elements que estan continguts a la Col·lecció especificada. |
| removeAllElements() | Elimina tots els components d'aquest vector i posa la seva mida a zero. |
| removeElement(Objecte o) | Elimina la primera ocurrència (índex més baix) de l'argument d'aquest vector. |
| removeElementAt (índex int) | Elimina el component a l'índex especificat. |
| removeRange (int de l'índex, int a l'índex) | Elimina d'aquesta llista tots els elements l'índex dels quals està entre fromIndex, inclòs, i toIndex, exclusiu. |
| retainAll(Col·lecció c) | Reté només els elements d'aquest vector que estan continguts a la col·lecció especificada. |
| set(índex int, objecte o) | Substitueix l'element a la posició especificada en aquest Vector per l'element especificat. |
| setElementAt(Objecte o, índex int) | Estableix el component a l'índex especificat d'aquest vector perquè sigui l'objecte especificat. |
| setSize(int newSize) | Estableix la mida d'aquest vector. |
| mida () | Retorna el nombre de components d'aquest vector. |
| subList(int de l'índex, int a l'índex) | Retorna una vista de la part d'aquesta llista entre fromIndex, inclòs, i toIndex, exclusiu. |
| toArray() | Retorna una matriu que conté tots els elements d'aquest vector en l'ordre correcte. |
| toArray(Objecte []matriu) | Retorna una matriu que conté tots els elements d'aquest vector en l'ordre correcte; el temps d'execució el tipus de la matriu retornada és el de la matriu especificada. |
| toString() | Retorna una representació de cadena d'aquest Vector, que conté la representació de cadena de cada element. |
| trimToSize() | Retalla la capacitat d'aquest vector perquè sigui la mida actual del vector. |
Prioritzar l'ús de Dec sobre pila -:
La classe Stack a Java és una classe heretada de la qual n'hereta Vector en Java . És una classe segura per a fils i, per tant, implica una sobrecàrrega quan no necessitem seguretat per a fils. Es recomana utilitzar ArrayDeque per a la implementació de la pila, ja que és més eficient en un entorn d'un sol fil.
Java
convenció de noms java
// 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());> >}> }> |
>
>
Sortida:
B B>
Una raó més per utilitzar Deque sobre Stack és que Deque té la capacitat d'utilitzar fluxos convertits a llista mantenint el concepte LIFO aplicat mentre que Stack no.
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(); } }> |
>
>Sortida
Using Stack - 1 2 Using Deque - 2 1>