Java Stack Example

What is a Java Stack class?

A Java stack class implementation is based on the stack data structure. It follows the concept of the Last-In-First-Out(LIFO) concept which means the element that we insert last will be removed first. In other words, we can delete elements only from the top of the stack. The Java Stack class extends the Vector class and hence imports the methods of the Vector class as well. In this tutorial, we will learn about the Java stack class and methods with stack implementation in Java with examples and its different operations.

Working of a Java Stack data structure

The stack class in Java has two main operations to insert and remove elements. The push() method inserts an element and the pop() method deletes an element. Both the operations occur from the top of the stack.

The below diagram represents the working of a stack data structure in java.

Push operation:

As we insert each element into a stack using the push method, the last inserted element will always be on the top. It keeps adding elements on top of the older element. For example, first, we insert 10, then 20. In this case, 20 will be on top of 10, and so on.

Pop operation:

The pop method removes the latest element that we insert from the top of the stack. This follows the concept of LIFO which is Last-In-First-Out. For example, if we have 5 elements 10,20,30,40 and 50. Hence when we use the pop() method, it removes the value 50 first since that is the topmost element present in the stack.

How to create a stack in Java

We can create an empty stack using the default constructor stack().  To implement the stack data structure, we need to import the java.util.stack package.

Stack<E> stack = new Stack<E>();

E denotes the generics type.

Stack methods in Java

Below are the methods that are part of the Stack class.

Below are the methods in the Vector class. The stack class imports all the methods of the Vector class as well.

Java Stack examples

Below are the various Java stack examples of different stack operations in java.

Example: push() – Adding elements to a stack

The below example illustrates how to insert an element to a Java stack using the push() method. This is equivalent to the add() method of the Vector class. Each time it adds the element, it goes to the bottom of the stack so that the last inserted element will be on the top.

import java.util.Stack;

public class StackDemo {

  public static void main(String[] args) {
    Stack<Integer> s = new Stack<Integer>();
    s.push(10);
    s.push(20);
    s.push(30);
    s.push(40);
    s.push(50);
    
    System.out.println("Elements in stack: " + s);
  }

}

Elements in stack: [10, 20, 30, 40, 50]

Example: pop() – Remove elements from a stack

The below example shows how to delete elements from the stack. It removes the latest element from the top of the stack first. Hence the first pop() method returns 50 which is the last element that is inserted and followed by the element 40 for the second pop() method.

import java.util.Stack;

public class StackDemo {

  public static void main(String[] args) {
    Stack<Integer> s = new Stack<Integer>();
    s.push(10);
    s.push(20);
    s.push(30);
    s.push(40);
    s.push(50);
    
    System.out.println("Elements in stack: " + s);
    
    int x = s.pop();
    System.out.println("Element removed from stack: " + x);
    
    x = s.pop();
    System.out.println("Element removed from stack: " + x);
  }

}

Elements in stack: [10, 20, 30, 40, 50]
Element removed from stack: 50
Element removed from stack: 40

Example: search() method

The search() method searches for the specific element and returns the position starting from the top of the stack. In this example, element 30 is present in the 3rd position and element 40 in the 2nd position.

import java.util.Stack;

public class StackDemo {

  public static void main(String[] args) {
    Stack<Integer> s = new Stack<Integer>();
    s.push(10);
    s.push(20);
    s.push(30);
    s.push(40);
    s.push(50);
    
    System.out.println("Elements in stack: " + s);
    
    System.out.println("The index of element 30 using search method: " + s.search(30));
    System.out.println("The index of element 40 using search method: " + s.search(40));
  }

}

Elements in stack: [10, 20, 30, 40, 50]
The index of element 30 using search method: 3
The index of element 40 using search method: 2

Example: peek() method

The peek() method returns the last inserted element which is the topmost element. This method only retrieves the value and does not remove it from the stack.

import java.util.Stack;

public class StackDemo {

  public static void main(String[] args) {
    Stack<Integer> s = new Stack<Integer>();
    s.push(10);
    s.push(20);
    s.push(30);
    s.push(40);
    s.push(50);
    
    System.out.println("Elements in stack: " + s);
    System.out.println("Element returned using the peek() method: " + s.peek());
    
  }

}

Elements in stack: [10, 20, 30, 40, 50]
Element returned using the peek() method: 50

Example: Iterate through Java stack elements

We can iterate through all elements in the Java stack using the iterator method present in the Vector class. The below example shows how to iterate a stack.

import java.util.Iterator;
import java.util.Stack;

public class StackDemo {

  public static void main(String[] args) {
    Stack<Integer> s = new Stack<Integer>();
    s.push(10);
    s.push(20);
    s.push(30);
    s.push(40);
    s.push(50);
    
    System.out.println("Elements in stack: " + s);
    
    Iterator<Integer> i = s.iterator();
    while(i.hasNext())
      System.out.println(i.next());
    
  }

}

Elements in stack: [10, 20, 30, 40, 50]
10
20
30
40
50

Example: Clear a stack check if empty

Below is an example to clear the elements in the stack using the clear() method and check if the attack is empty using the isEmpty() method. Initially, whenever we create a stack, it will be empty. This is also called an empty stack.

import java.util.Iterator;
import java.util.Stack;

public class StackDemo {

  public static void main(String[] args) {
    Stack<Integer> s = new Stack<Integer>();
    
    s.push(10);
    s.push(20);
    s.push(30);
    s.push(40);
    s.push(50);
    
    System.out.println("Elements in stack: " + s);
    System.out.println("Is stack empty: " + s.isEmpty());
    
    s.clear();
    System.out.println("Elements in stack after clear method: " + s);
    System.out.println("Is stack empty: " + s.isEmpty());
    
  }

}

Elements in stack: [10, 20, 30, 40, 50]
Is stack empty: false
Elements in stack after clear method: []
Is stack empty: true

Example: Convert Java List to stack

We can convert a Java List to stack by adding a collection of list elements to stack using the addAll() method.

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class ListToStack {

  public static void main(String[] args) {
    Stack<Integer> s = new Stack<Integer>();
    List<Integer> l = new ArrayList<Integer>();
    
    l.add(10);
    l.add(20);
    l.add(30);
    l.add(40);
    l.add(50);
    
    s.addAll(l);
    System.out.println("Elements in stack from List: " + s);

  }

}

Elements in stack from List: [10, 20, 30, 40, 50]

Example: Convert array to a stack

In the below example, we add array elements to a stack using the push() method.

import java.util.Stack;

public class ArrayToStack {

  public static void main(String[] args) {
    Stack<Integer> s = new Stack<Integer>();
    int[] num = {10,20,30,40,50};
    
    for(int i : num)
      s.push(i);
    
    System.out.println("Array elements in stack: " + s);
  }

}

Array elements in stack: [10, 20, 30, 40, 50]

Example: Convert stack to an array

We can also convert a stack to an array using the toArray() method as in the below example.

import java.util.Stack;

public class StackToArray {

  public static void main(String[] args) {
    Stack<Integer> s = new Stack<Integer>();
    s.push(10);
    s.push(20);
    s.push(30);
    
    System.out.println("Elements in stack: " + s);
    
    Object[] arr = s.toArray();
    System.out.println("Elements in Array: ");
    for(int i=0;i<arr.length;i++)
      System.out.print(arr[i] + " ");
  }

}

Elements in stack: [10, 20, 30]
Elements in Array: 
10 20 30

Conclusion

In this tutorial, we have seen how to use the Java stack class and methods along with stack implementation and examples.

Reference