Clase de pila en Java

El marco de Java Collection proporciona una clase Stack que modela e implementa una estructura de datos Stack . La clase se basa en el principio básico de último en entrar, primero en salir. Además de las operaciones básicas de inserción y extracción, la clase proporciona tres funciones más de vaciar, buscar y mirar. También se puede decir que la clase extiende Vector y trata a la clase como una pila con las cinco funciones mencionadas. La clase también puede denominarse subclase de Vector.

El siguiente diagrama muestra la jerarquía de la clase Stack : 

La clase admite un constructor predeterminado Stack() que se usa para crear una pila vacía . 

Declaración:

public class Stack<E> extends Vector<E>

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 necesita ser implementada por una clase para permitir que sus objetos sean clonados.
• Iterable<E>: esta interfaz representa una colección de objetos iterables, lo que significa que se pueden iterar.
• Collection<E>: una colección representa un grupo de objetos conocidos como sus elementos. La interfaz Collection se utiliza para pasar colecciones de objetos donde se desea la máxima generalidad.
• List<E>: la interfaz List proporciona una forma de almacenar la colección ordenada. Es una interfaz secundaria de Collection.
• RandomAccess: esta es una interfaz de marcador utilizada por las implementaciones de List para indicar que admiten acceso aleatorio rápido (generalmente en tiempo constante).

¿Cómo crear una pila?

Para crear una pila, debemos importar el paquete java.util.stack y usar el constructor Stack() de esta clase. El siguiente ejemplo crea una pila vacía.

Pila<E> pila = nueva Pila<E>();

Aquí E es el tipo de Objeto.

Ejemplo: 

// 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<Integer> stack)
    {
        for(int i = 0; i < 5; i++)
        {
            stack.push(i);
        }
    }
      
    // Popping element from the top of the stack
    static void stack_pop(Stack<Integer> 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<Integer> stack)
    {
        Integer element = (Integer) stack.peek();
        System.out.println("Element on stack top: " + element);
    }
      
    // Searching element in the stack
    static void stack_search(Stack<Integer> 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<Integer> stack = new Stack<Integer>();
  
        stack_push(stack);
        stack_pop(stack);
        stack_push(stack);
        stack_peek(stack);
        stack_search(stack, 2);
        stack_search(stack, 6);
    }
}

Producción:

Pop Operation:
4
3
2
1
0
Element on stack top: 4
Element is found at position: 3
Element not found

Realización de varias operaciones en la clase Stack

1. Agregar elementos: para agregar un elemento a la pila, podemos usar el método push() . Esta operación push() coloca el elemento en la parte superior de la pila.

// 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<String> stack2 = new Stack<String>();
  
        // 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. Acceso 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 el método peek() . El elemento recuperado no se elimina ni elimina de la pila. 

// 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<String> stack = new Stack<String>();
  
        // 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);
    }
}

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 método pop() . El elemento se extrae de la parte superior de la pila y se elimina de la misma.

// 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<Integer> stack = new Stack<Integer>();
  
        // 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]

 Métodos en la clase Stack 

Métodos heredados de la clase java.util.Vector

Nota: tenga en cuenta que 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 una sobrecarga cuando no necesitamos seguridad para subprocesos. Se recomienda utilizar ArrayDeque para la implementación de la pila, ya que es más eficiente en un entorno de subproceso único.

// A Java Program to show implementation
// of Stack using ArrayDeque
  
import java.util.*;
  
class GFG {
    public static void main (String[] args) {
        Deque<Character> stack = new ArrayDeque<Character>();
        stack.push('A');
        stack.push('B');
        System.out.println(stack.peek());
        System.out.println(stack.pop());
    }
}

Producción: 

B
B