Java Marco de colección proporciona una clase Stack que modela e implementa un El siguiente diagrama muestra la jerarquía de la clase Stack :
La clase apoya a uno. Constructor predeterminado Pila() que se utiliza para crear una pila vacía .
Declaración:
public class Stack extends Vector>
Todas las interfaces implementadas:
- Serializable: Es una interfaz de marcador que las clases deben implementar si se van a serializar y deserializar.
- Clonable: Esta es una interfaz en Java que debe ser implementada por una clase para permitir la clonación de sus objetos.
- Iterable: Esta interfaz representa una colección de objetos que es iterable, es decir, que se puede iterar.
- Recopilación: Una Colección representa un grupo de objetos conocidos como sus elementos. La interfaz Colección se utiliza para pasar colecciones de objetos donde se desea la máxima generalidad.
- Lista: La interfaz Lista proporciona una forma de almacenar la colección ordenada. Es una interfaz secundaria de Collection.
- Acceso aleatorio: Esta es una interfaz de marcador utilizada por las implementaciones de Lista para indicar que admiten un acceso aleatorio rápido (generalmente de tiempo constante).
¿Cómo crear una pila?
Para crear una pila, debemos importar java.util.pila paquete y utilice el constructor Stack() de esta clase. El siguiente ejemplo crea una pila vacía.
Pila pila = nueva pila();
Aquí E es el tipo de Objeto.
Ejemplo:
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>);> >}> }> |
comando en el nodo js
>
>
Producción:
Pop Operation: 4 3 2 1 0 Element on stack top: 4 Element is found at position: 3 Element not found>
Realizar varias operaciones en la clase Stack
1. Agregar elementos: Para agregar un elemento a la pila, podemos usar el método empujar() . Este empujar() operación coloque el elemento en la parte 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);> >}> }> |
>
>
Producción:
[4, All, Geeks] [Geeks, For, Geeks]>
2. Accediendo al Elemento: Para recuperar o buscar el primer elemento de la Pila o el elemento presente en la parte superior de la Pila, podemos usar ojeada() método. El elemento recuperado no se elimina ni se 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);> >}> }> |
látex de tamaño de texto
>
>
Producción:
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ón de elementos: Para sacar un elemento de la pila, podemos usar el estallido() método. El elemento se extrae de la parte superior de la pila y se elimina de la misma.
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);> >}> }> |
>
>
Producción:
Initial Stack: [10, 15, 30, 20, 5] Popped element: 5 Popped element: 20 Stack after pop operation [10, 15, 30]>
Ejemplo
En Java, la clase Stack es una subclase de la clase Vector y representa una pila de objetos de último en entrar, primero en salir (LIFO). Extiende la clase Vector para permitir una fácil implementación de la estructura de datos de la pila.
Aquí hay un ejemplo de cómo puede usar la clase Stack en 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());> >}> >}> }> |
>
>Producción
4 3 2 1>
En este ejemplo, primero importamos la clase Stack del paquete java.util. Luego creamos un nuevo objeto Stack llamado stack usando el constructor predeterminado. Empujamos cuatro números enteros a la pila usando el método push(). Luego sacamos los elementos de la pila usando el método pop() dentro de un bucle while. El método isEmpty() se utiliza para comprobar si la pila está vacía antes de intentar extraer un elemento.
Este código crea una pila de números enteros y coloca 4 números enteros en la pila en el orden 1 -> 2 -> 3 -> 4. Luego extraemos elementos de la pila uno por uno usando el método pop(), que elimina y devuelve el elemento superior de la pila. Dado que la pila sigue un orden de último en entrar, primero en salir (LIFO), los elementos se extraen en el orden inverso al de inserción, lo que da como resultado el resultado que se muestra arriba.
La clase Stack proporciona varios otros métodos para manipular la pila, como peek() para recuperar el elemento superior sin eliminarlo, search() para buscar un elemento en la pila y devolver su posición, y size() para devolver el valor actual. tamaño de la pila. La clase Stack también proporciona varios constructores para crear una pila con una capacidad inicial específica o copiar una pila existente.
Métodos en la clase Stack
| MÉTODO cómo mostrar una aplicación en Android | DESCRIPCIÓN |
|---|---|
| vacío() | Devuelve verdadero si no hay nada en la parte superior de la pila. De lo contrario, devuelve falso. |
| ojeada() | Devuelve el elemento en la parte superior de la pila, pero no lo elimina. |
| estallido() | Elimina y devuelve el elemento superior de la pila. Una 'Excepción de pila vacía' Se produce una excepción si llamamos a pop() cuando la pila de invocación está vacía. |
| empujar (elemento objeto) | Empuja un elemento en la parte superior de la pila. |
| buscar(elemento objeto) | Determina si un objeto existe en la pila. Si se encuentra el elemento, Devuelve la posición del elemento desde la parte superior de la pila. De lo contrario, devuelve -1. |
Métodos heredados de la clase java.util.Vector
| MÉTODO | DESCRIPCIÓN |
|---|---|
| agregar (objeto objeto) | Agrega el elemento especificado al final de este vector. |
| agregar (índice int, objeto obj) | Inserta el elemento especificado en la posición especificada en este vector. |
| agregarTodo(Colección c) | Agrega todos los elementos de la Colección especificada al final de este Vector, en el orden en que son devueltos por el iterador de la colección especificada. |
| addAll(índice int, Colección c) | Inserta todos los elementos de la Colección especificada en este Vector en la posición especificada. |
| agregarElemento(Objeto o) | Agrega el componente especificado al final de este vector, aumentando su tamaño en uno. |
| capacidad() | Devuelve la capacidad actual de este vector. |
| claro() | Elimina todos los elementos de este vector. |
| clon() | Devuelve un clon de este vector. |
| contiene(Objeto o) | Devuelve verdadero si este vector contiene el elemento especificado. |
| contieneTodo(Colección c) | Devuelve verdadero si este Vector contiene todos los elementos de la Colección especificada. |
| copiar en (objeto []matriz) | Copia los componentes de este vector en la matriz especificada. |
| elementoAt(índice int) | Devuelve el componente en el índice especificado. |
| elementos() | Devuelve una enumeración de los componentes de este vector. |
| asegurarCapacidad(int minCapacity) | Aumenta la capacidad de este vector, si es necesario, para garantizar que pueda contener al menos el número de componentes especificado por el argumento de capacidad mínima. |
| es igual() | Compara el objeto especificado con este vector para determinar la igualdad. |
| primerElemento() | Devuelve el primer componente (el elemento en el índice 0) de este vector. |
| obtener (índice int) | Devuelve el elemento en la posición especificada en este Vector. |
| código hash() | Devuelve el valor del código hash para este vector. |
| índice de (objeto o) | Devuelve el índice de la primera aparición del elemento especificado en este vector, o -1 si este vector no contiene el elemento. |
| indexOf(Objeto o, int índice) | Devuelve el índice de la primera aparición del elemento especificado en este vector, buscando hacia adelante desde el índice, o devuelve -1 si no se encuentra el elemento. |
| insertElementAt(Objeto o, índice int) | Inserta el objeto especificado como un componente en este vector en el índice especificado. |
| esta vacio() | Prueba si este vector no tiene componentes. |
| iterador() | Devuelve un iterador sobre los elementos de esta lista en la secuencia adecuada. |
| último elemento() | Devuelve el último componente del vector. |
| último índice de (objeto o) | Devuelve el índice de la última aparición del elemento especificado en este vector, o -1 Si este vector no contiene el elemento. |
| lastIndexOf(Objeto o, índice int) | Devuelve el índice de la última aparición del elemento especificado en este vector, busca hacia atrás desde el índice, o devuelve -1 si no se encuentra el elemento. |
| listaIterador() | Devuelve un iterador de lista sobre los elementos de esta lista (en la secuencia adecuada). |
| listaIterator(índice int) | Devuelve un iterador de lista sobre los elementos de esta lista (en la secuencia adecuada), comenzando en la posición especificada en la lista. |
| eliminar (índice int) | Elimina el elemento en la posición especificada en este Vector. |
| eliminar (Objeto o) | Elimina la primera aparición del elemento especificado en este vector. Si el vector no contiene el elemento, no se modifica. |
| eliminarTodo(Colección c) | Elimina de este Vector todos sus elementos contenidos en la Colección especificada. |
| eliminarTodosLosElementos() | Elimina todos los componentes de este vector y establece su tamaño en cero. |
| eliminarElemento(Objeto o) | Elimina la primera aparición (con el índice más bajo) del argumento de este vector. |
| eliminarElementAt(índice int) | Elimina el componente en el índice especificado. |
| removeRange(int del índice, int al índice) | Elimina de esta lista todos los elementos cuyo índice esté entre fromIndex, inclusive, y toIndex, exclusivo. |
| retenerTodo(Colección c) | Conserva únicamente los elementos de este Vector que están contenidos en la Colección especificada. |
| set(índice int, Objeto o) | Reemplaza el elemento en la posición especificada en este Vector con el elemento especificado. |
| setElementAt(Objeto o, índice int) | Establece el componente en el índice especificado de este vector para que sea el objeto especificado. |
| establecerTamaño(int nuevoTamaño) | Establece el tamaño de este vector. |
| tamaño() | Devuelve el número de componentes de este vector. |
| subLista(int del índice, int al índice) | Devuelve una vista de la parte de esta Lista entre fromIndex, inclusive, y toIndex, exclusivo. |
| a matriz() | Devuelve una matriz que contiene todos los elementos de este vector en el orden correcto. |
| toArray(Objeto []matriz) | Devuelve una matriz que contiene todos los elementos de este Vector en el orden correcto; el tiempo de ejecución El tipo de matriz devuelta es el de la matriz especificada. |
| Encadenar() | Devuelve una representación de cadena de este vector, que contiene la representación de cadena de cada elemento. |
| recortarToSize() | Recorta la capacidad de este vector para que tenga el tamaño actual del vector. |
Priorizar el uso de Deque sobre pila -:
La clase Stack en Java es una clase heredada y hereda de Vector en Java . Es una clase segura para subprocesos y, por lo tanto, implica gastos generales cuando no necesitamos seguridad para subprocesos. Se recomienda utilizar ArrayDeque para la implementación de pila, ya que es más eficiente en un entorno de un solo subproceso.
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());> >}> }> |
>
cadena java de matriz
>
Producción:
B B>
Una razón más para usar Deque en lugar de Stack es que Deque tiene la capacidad de usar transmisiones para convertir a listas manteniendo aplicado el concepto LIFO, mientras 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(); } }> |
>
>Producción
Using Stack - 1 2 Using Deque - 2 1>