El pila és una estructura de dades lineal que s'utilitza per emmagatzemar la col·lecció d'objectes. Es basa en Darrer en entrar, primer en sortir (LIFO). Col·lecció Java framework proporciona moltes interfícies i classes per emmagatzemar la col·lecció d'objectes. Un d'ells és el Classe de pila que ofereix diferents operacions com push, pop, search, etc.

En aquesta secció, parlarem de Classe Java Stack , la seva mètodes, i implementar l'estructura de dades de la pila en a Programa Java . Però abans de passar a la classe Java Stack, tingueu una visió ràpida de com funciona la pila.

concat cadena java

L'estructura de dades de la pila té les dues operacions més importants que són empènyer i pop . L'operació push insereix un element a la pila i l'operació pop elimina un element de la part superior de la pila. Vegem com funcionen a la pila.

Introduïm 20, 13, 89, 90, 11, 45, 18, respectivament a la pila.

Traiem (pop) 18, 45 i 11 de la pila.

Pila buida: Si la pila no té cap element es coneix com a pila buida . Quan la pila està buida, el valor de la variable superior és -1.

Quan empenyem un element a la pila, la part superior està augmentat en 1 . A la figura següent,

• Premeu 12, a dalt=0
• Premeu 6, a dalt=1
• Premeu 9, a dalt=2

Quan sortim un element de la pila, el valor de top és disminuït en 1 . A la figura següent, hem aparegut 9.

La taula següent mostra els diferents valors de la part superior.

Classe de pila de Java

A Java, Pila és una classe que s'inclou en el marc de col·lecció que amplia el Vector classe. També implementa interfícies Llista, Col·lecció, Iterable, Clonable, Serialitzable. Representa la pila d'objectes LIFO. Abans d'utilitzar la classe Stack, hem d'importar eljava.utilpaquet. La classe de pila organitzada a la jerarquia del marc de col·leccions, tal com es mostra a continuació.

Constructor de classes de pila

La classe Stack només conté constructor per defecte que crea una pila buida.

 public Stack() 

Creació d'una pila

Si volem crear una pila, primer, importeu el fitxerjava.utilpaquet i creeu un objecte de la classe Stack.

 Stack stk = new Stack(); 

O

 Stack stk = new Stack(); 

On type indica el tipus de pila com Integer, String, etc.

Mètodes de la classe Stack

Podem realitzar operacions push, pop, peek i cerca a la pila. La classe Java Stack proporciona principalment cinc mètodes per realitzar aquestes operacions. Juntament amb això, també proporciona tots els mètodes del Classe vectorial Java .

Stack Class empty() Mètode

El buit() mètode de la classe Stack comproveu que la pila estigui buida o no. Si la pila està buida, retorna true, en cas contrari retorna false. També podem utilitzar el mètode isEmpty() de la classe Vector .

Sintaxi

 public boolean empty() 

Devolucions: El mètode retorna true si la pila està buida, en cas contrari retorna false.

A l'exemple següent, hem creat una instància de la classe Stack. Després d'això, hem invocat el mètode empty() dues vegades. La primera vegada que torna veritat perquè no hem introduït cap element a la pila. Després d'això, hem introduït elements a la pila. De nou hem invocat el mètode empty() que retorna fals perquè la pila no està buida.

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

Sortida:

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

Stack Class push() Mètode

El mètode insereix un element a la part superior de la pila. Funciona igual que el mètode addElement(item) de la classe Vector. Passa un paràmetre article per ser empès a la pila.

Sintaxi

 public E push(E item) 

Paràmetre: Un element que cal empènyer a la part superior de la pila.

Devolucions: El mètode retorna l'argument que hem passat com a paràmetre.

Stack Class pop() Mètode

El mètode elimina un objecte a la part superior de la pila i retorna el mateix objecte. Es tira EmptyStackException si la pila està buida.

Sintaxi

 public E pop() 

Devolucions: Retorna un objecte que es troba a la part superior de la pila.

Implementem la pila en un programa Java i realitzem operacions push i pop.

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

Sortida:

 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() Mètode

Mira l'element que es troba a la part superior de la pila. També llença EmptyStackException si la pila està buida.

Sintaxi

 public E peek() 

Devolucions: Retorna els elements superiors de la pila.

Vegem un exemple del mètode 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); } } 

Sortida:

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

Stack Class search() Mètode

El mètode cerca l'objecte de la pila des de la part superior. Analitza un paràmetre que volem cercar. Retorna la ubicació basada en 1 de l'objecte a la pila. L'objecte més alt de la pila es considera a la distància 1.

Suposem que o és un objecte de la pila que volem cercar. El mètode retorna la distància des de la part superior de la pila de l'ocurrència més propera a la part superior de la pila. S'utilitza és igual() mètode per cercar un objecte a la pila.

com ordenar una matriu en java

Sintaxi

 public int search(Object o) 

Paràmetre: o és l'objecte que es vol cercar.

Devolucions: Retorna la ubicació de l'objecte des de la part superior de la pila. Si retorna -1, vol dir que l'objecte no està a la pila.

Vegem un exemple del mètode 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); } } 

Operacions de pila de Java

Mida de la pila

També podem trobar la mida de la pila utilitzant el mètode size() de la classe Vector . Retorna el nombre total d'elements (mida de la pila) de la pila.

Sintaxi

 public int size() 

Vegem un exemple del mètode size() de la classe 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); } } 

Sortida:

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

Elements iteratius

Iterar significa buscar els elements de la pila. Podem obtenir elements de la pila mitjançant tres mètodes diferents:

• Utilitzant iterador() Mètode
• Utilitzant per cadascú() Mètode
• Utilitzant listIterator() Mètode

Utilitzant el mètode iterator().

És el mètode de la interfície Iterator. Retorna un iterador sobre els elements de la pila. Abans d'utilitzar el mètode iterator() importeu el fitxerjava.util.Iteratorpaquet.

Sintaxi

 Iterator iterator() 

Realitzem una iteració sobre la pila.

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

Sortida:

 BMW Audi Ferrari Bugatti Jaguar 

Utilitzant el mètode forEach().

Java proporciona un mètode forEach() per iterar sobre els elements. El mètode es defineix al Iterable i corrent interfície.

1 de 1000

Sintaxi

 default void forEach(Consumeraction) 

Anem a iterar sobre la pila utilitzant el mètode 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); }); } } 

Sortida:

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

Utilitzant el mètode listIterator().

Aquest mètode retorna un iterador de llista sobre els elements de la llista esmentada (en seqüència), començant a la posició especificada de la llista. Itera la pila de dalt a baix.

Sintaxi

 ListIterator listIterator(int index) 

Paràmetre: El mètode analitza un paràmetre anomenat índex.

Devolucions: Aquest mètode retorna un iterador de llista sobre els elements, en seqüència.

Excepció: Es tira IndexOutOfBoundsException si l'índex està fora de rang.

Anem a iterar sobre la pila utilitzant el mètode 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); } } } 

Sortida:

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