El pila Es una estructura de datos lineal que se utiliza para almacenar la colección de objetos. Está basado en Último en entrar primero en salir (LIFO). colección java framework proporciona muchas interfaces y clases para almacenar la colección de objetos. Uno de ellos es el clase de pila que proporciona diferentes operaciones como push, pop, búsqueda, etc.

En esta sección, discutiremos la Clase de pila Java , es métodos, y implementar la estructura de datos de la pila en un programa java . Pero antes de pasar a la clase Java Stack, tenga una vista rápida de cómo funciona la pila.

La estructura de datos de la pila tiene las dos operaciones más importantes que son empujar y estallido . La operación de inserción inserta un elemento en la pila y la operación de extracción elimina un elemento de la parte superior de la pila. Veamos cómo funcionan en pila.

Empujemos 20, 13, 89, 90, 11, 45, 18, respectivamente, en la pila.

Eliminemos (saquemos) 18, 45 y 11 de la pila.

Pila vacía: Si la pila no tiene ningún elemento se conoce como pila vacía . Cuando la pila está vacía, el valor de la variable superior es -1.

Cuando empujamos un elemento en la pila, la parte superior es aumentado en 1 . En la siguiente figura,

• Empuje 12, arriba = 0
• Empuje 6, arriba = 1
• Empuje 9, arriba = 2

Cuando sacamos un elemento de la pila, el valor de top es disminuido en 1 . En la siguiente figura, hemos aparecido 9.

La siguiente tabla muestra los diferentes valores de la parte superior.

Clase de pila Java

En Java, Pila es una clase que cae bajo el marco de la Colección que extiende el Vector clase. También implementa interfaces. Lista, Colección, Iterable, Clonable, Serializable. Representa la pila de objetos LIFO. Antes de usar la clase Stack, debemos importar eljava.utilpaquete. La clase de pila organizada en la jerarquía del marco de Colecciones, como se muestra a continuación.

Constructor de clases de pila

La clase Stack contiene sólo el Constructor predeterminado eso crea una pila vacía.

 public Stack() 

Creando una pila

Si queremos crear una pila, primero importamos eljava.utilempaquetar y crear un objeto de la clase Stack.

 Stack stk = new Stack(); 

O

 Stack stk = new Stack(); 

Donde tipo denota el tipo de pila como Integer, String, etc.

Métodos de la clase Stack

Podemos realizar operaciones de inserción, extracción, visualización y búsqueda en la pila. La clase Java Stack proporciona principalmente cinco métodos para realizar estas operaciones. Junto con esto, también proporciona todos los métodos de la Clase vectorial Java .

edad de dharmendra

Método de clase de pila vacía ()

El vacío() El método de la clase Stack comprueba que la pila esté vacía o no. Si la pila está vacía, devuelve verdadero; en caso contrario, devuelve falso. También podemos utilizar el método isEmpty() de la clase Vector.

Sintaxis

 public boolean empty() 

Devoluciones: El método devuelve verdadero si la pila está vacía; en caso contrario, devuelve falso.

En el siguiente ejemplo, hemos creado una instancia de la clase Stack. Después de eso, hemos invocado el método vacío() dos veces. La primera vez que regresa verdadero porque no hemos insertado ningún elemento en la pila. Después de eso, hemos insertado elementos en la pila. Nuevamente hemos invocado el método vacío() que devuelve FALSO porque la pila no está vacía.

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

Producción:

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

Método push() de clase de pila

El método inserta un elemento en la parte superior de la pila. Funciona igual que el método addElement(item) de la clase Vector. Pasa un parámetro artículo para ser empujado hacia la pila.

Sintaxis

 public E push(E item) 

Parámetro: Un elemento que se colocará en la parte superior de la pila.

Devoluciones: El método devuelve el argumento que le hemos pasado como parámetro.

Método pop() de clase de pila

El método elimina un objeto en la parte superior de la pila y devuelve el mismo objeto. arroja Excepción de pila vacía si la pila está vacía.

Sintaxis

 public E pop() 

Devoluciones: Devuelve un objeto que está en la parte superior de la pila.

Implementemos la pila en un programa Java y realicemos operaciones push y 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); } } 

Producción:

 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] 

Método peek() de clase de pila

Mira el elemento que está en la parte superior de la pila. tambien tira Excepción de pila vacía si la pila está vacía.

Sintaxis

 public E peek() 

Devoluciones: Devuelve los elementos superiores de la pila.

Veamos un ejemplo del método 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); } } 

Producción:

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

Método de búsqueda de clase de pila ()

El método busca el objeto en la pila desde arriba. Analiza un parámetro que queremos buscar. Devuelve la ubicación basada en 1 del objeto en la pila. El objeto más alto de la pila se considera a la distancia 1.

Supongamos que o es un objeto en la pila que queremos buscar. El método devuelve la distancia desde la parte superior de la pila del suceso más cercano a la parte superior de la pila. Usa es igual() Método para buscar un objeto en la pila.

Sintaxis

 public int search(Object o) 

Parámetro: o es el objeto que se desea buscar.

Devoluciones: Devuelve la ubicación del objeto desde la parte superior de la pila. Si devuelve -1, significa que el objeto no está en la pila.

Veamos un ejemplo del método search().

hiba bukhari

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

Operaciones de pila de Java

Tamaño de la pila

También podemos encontrar el tamaño de la pila usando el método size() de la clase Vector. Devuelve el número total de elementos (tamaño de la pila) en la pila.

Sintaxis

 public int size() 

Veamos un ejemplo del método size() de la clase 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); } } 

Producción:

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

Iterar elementos

Iterar significa buscar los elementos de la pila. Podemos recuperar elementos de la pila usando tres métodos diferentes que son los siguientes:

• Usando iterador() Método
• Usando para cada() Método
• Usando listaIterador() Método

Usando el método iterador()

Es el método de la interfaz Iterator. Devuelve un iterador sobre los elementos de la pila. Antes de usar el método iterator() importe eljava.util.Iteradorpaquete.

Sintaxis

 Iterator iterator() 

Realicemos una iteración 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); } } } 

Producción:

 BMW Audi Ferrari Bugatti Jaguar 

Usando el método forEach()

Java proporciona un método forEach() para iterar sobre los elementos. El método está definido en el iterable y Arroyo interfaz.

tabla en reaccionar

Sintaxis

 default void forEach(Consumeraction) 

Repitamos la pila usando el método 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); }); } } 

Producción:

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

Usando el método listIterator()

Este método devuelve un iterador de lista sobre los elementos de la lista mencionada (en secuencia), comenzando en la posición especificada en la lista. Itera la pila de arriba a abajo.

Sintaxis

 ListIterator listIterator(int index) 

Parámetro: El método analiza un parámetro llamado índice.

Devoluciones: Este método devuelve un iterador de lista sobre los elementos, en secuencia.

Excepción: arroja Excepción IndexOutOfBounds si el índice está fuera de rango.

Repitamos la pila usando el método 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); } } } 

Producción:

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