Java Stack

Java has a stack class that helps in implementing a stack data structure. We can also refer to this class as a subclass of the vector. As we are aware of the fact that stack follows last in first out the principle in addition to push and pop operations. Last in first out (LIFO) means when an element is added to the top of the stack, the element will also be removed from the top of the stack. The stack class in Java has three additional functions which are empty, search and peek.

We need to know certain things about stack before we create one.

• A stack contains no elements when it is created. We need to push the elements into the stack.
• The last element pushed inside the stack will be operated first always.

Collection <-- List <-- Vector <-- Stack

Java Stack Methods

Push() Object: It will send the element to the top of the stack. Once you create a stack, you need to have elements to fill the stack. After gathering elements, we use push() operation to fill the stack. The syntax is:

Stack<String> stack = new Stack< String>( ); 
stack.push(“10”);

Pop() Object: It removes the top element of the stack. When the user calls pop() operation, an exception “EmptyStackException” is thrown when the stack is empty. When we push the element into the Java stack class, we can anytime pop it back. To implement the pop() operation, we follow the syntax below:

Stack<String> stack = new Stack< String>( ); 
stack.push(“10”);
String top = stack.pop( );

Peek() Object: This operation sends the object to the top but it doesn’t remove the element from there. So, it tends to return the position of an element present at the top.

Stack<String> stack = new Stack< String>( ); 
stack.push(“10”);
String top = stack.peek( );

Boolean empty(): This operation will return true when the stack has elements. Otherwise, it will return false.

int search(): We use it to check the presence of an element in the stack. If the search operation finds the element, the object is returned to the top of the stack. Otherwise, it returns -1.

Stack<String> stack = new Stack< String>( ); 
stack.push(“10”);
stack.push(“20”);
stack.push(“30”);
int.index = stack.search(“20”);

Stack creates an empty space which invokes the default constructor. The package we use for implementing stack class in Java is java.util.Stack. When the user imports this package, the following is the syntax to write stack class with generic type.

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

We have used “Type” here which indicates the type of the stack.

Stack in Java

import java.util.*;
public class DeveloperHelps {
static void showpush(Stack st, int a) {
      st.push(new Integer(a));
      System.out.println("push(" + a + ")");
      System.out.println("stack: " + st);
   }
static void showpop(Stack st) {
      System.out.print("pop -> ");
      Integer a = (Integer) st.pop();
      System.out.println(a);
      System.out.println("stack: " + st);
   }
public static void main(String args[]) {
      Stack st = new Stack();
      System.out.println("stack: " + st);
      showpush(st, 35);
      showpush(st, 42);
      showpush(st, 59);
      showpop(st);
      showpop(st);
      showpop(st);
      try {
         showpop(st);
      } catch (EmptyStackException e) {
         System.out.println("The stack is empty");
      }
   }
}

Run Code >>

The output of the above program will be:

stack: []
push(35)
stack: [35]
push(42)
stack: [35, 42]
push(59)
stack: [35, 42, 59]
pop -> 59
stack: [35, 42]
pop -> 42
stack: [35]
pop -> 35
stack: []
pop -> The stack is empty

The class inherits the following methods:

• java.util.vector
• java.util.AbstractList
• java.util.Object
• java.util.List