Stack in Java

Java provides a number of collection frameworks to store the collection of objects. Among the collection of data structures " Stack " is one of them. Stack is one of the linear data structures in Java. The main purpose of the " Stack " data structure is to store a collection of objects. It is based upon LIFO i.e., last in first out. It provides many operations like pop, push, etc…  It provides three more functions like search, empty, and peek.

• To insert an element into the stack we use push operator.
• To delete an element from the stack we use pop operator.
• To search for an element in the stack we use search method.

Stack class

Stack class comes under the collection framework in Java. It is a subclass of "Vector". Stack is a specially designed class for LIFO (last in first out) order It extends the Vector class. It also implements interfaces like List etc... To use the Stack class, we need to import the " java.util " package.

Constructor of Stack

The stack class supports one default constructor Stack(). This constructor is used to create an empty stack.

public class Stack() extends Vector()

How to create a Stack?

The Stack class is created by first importing the package “ java.util”.

Stack s = new Stack ();

Or

Stack <type> s = new Stack <> ();

In type, we write integer or string, etc…

StackConstructorExample.java

import java.util.Stack;
public class StackConstructorExample {  
    StackConstructorExample() {  
        System.out.println("Empty stack is created");  
    }  
    public static void main(String args[]) {  
        StackConstructorExample stack = new StackConstructorExample(); // calling constructor 
    }  
}

Output:

Operators in Stack class :

Whenever we use the word Stack, immediately two words come into our mind they are " push " and " pop ".

push() operator:

This operator is used to push or add an object into the stack. The element or object gets pushed on top of the stack. This operator returns the argument passed into it.

PushMethodExample.java

import java.util.*;  
public class PushExample {  
    public static void main(String args[]) {  
        Stack<String> stack = new Stack<String>();  // empty stack is created
        stack.push(" Welcome ");  
        stack.push(" To ");  
        stack.push(" JavaTpoint ");  
        System.out.println(" Stack at beginning : " + stack);  
        // Push elements into the stack  
        stack.push("Hello");  
        stack.push("Programmers");  
        // Displaying the final Stack  
        System.out.println("Final Stack: " + stack);  
    }  
}

Output:

pop() operator :

This operator in Java is used to pop or remove an element from the stack. Any kind of parameters are not allowed in this operator. When we use the pop() method it returns the topmost element of the stack and removes it from the stack. This operator throws "EmptyStackException" when the Stack is empty.

PopExample.java

import java.util.*;  
public class PopExample {  
    public static void main(String args[]) {  
        Stack<String> stack = new Stack<String>();  // empty stack is created
        stack.push(" Welcome ");  
        stack.push(" To ");  
        stack.push(" JavaTpoint ");  
        System.out.println(" Stack before poping: " + stack);  
        System.out.println(" Popped element: " + stack.pop());  // deleting topmost element (JavaTpoint)
        System.out.println(" Popped element: " + stack.pop());  // deleting next element (To)
        // Displaying the Stack after using the pop method 
        System.out.println(" Stack after pop operation " + stack);  
    }  
}

Output:

PopExample1.java

import java.util.*;  
public class PopExample1 {  
    public static void main(String args[]) {  
        Stack<String> stack = new Stack<String>();  //empty stack is created
        stack.push(" Welcome ");  
        stack.push(" To ");  
        stack.push(" JavaTpoint ");  
        System.out.println(" Stack before poping: " + stack);  
        System.out.println(" Popped element: " + stack.pop());  // deleting top most element (JavaTpoint)
        System.out.println(" Popped element: " + stack.pop());  // deleting next element (To)
        System.out.println(" popped element: " + stack.pop()); // delecting last element (Welcome)
        System.out.println(" popped element: " + stack.pop()); // Empty Stack Exception
         }  
}

Output :

The above program throws an error. There we are trying to delete an element from an empty stack, so it throws the "EmptyStackException" exception.

Methods in the Stack class :

The well-known methods of the Stack class are “ peek ”, “ search ” and “ empty ”.

peek() method in the Stack class :

To use the peek() method we need to import the " java.util.Stack " package. This method returns the topmost element of the stack. It only retrieves the topmost element but does not delete the element from the stack, this is the difference between the pop() operator and peek() method.

Syntax :

Stack name.peek();

PeekMethodExample.java

import java.util.Stack;  
public class PeekMethodExample {  
    public static void main(String args[]) {  
        Stack<String> stack = new Stack<String>(); // empty stack is created
        stack.push(" Welcome ");  // adding elements to the stack
        stack.push(" To ");  
        stack.push(" JavaTpoint ");  
        System.out.println(" Stack before using peek: " + stack);  
        System.out.println(" Displaying the top element using peek method : " + stack.peek());  // using peek() method
        System.out.println(" Stack after using peek: " + stack);  
    }  
}

Output :

PeekMethodExample1.java

import java.util.Stack;  
public class PeekMethodExample1 {  
    public static void main(String args[]) {  
        Stack<String> stack = new Stack<String>(); // empty stack is created
        System.out.println(" Stack before using peek: " + stack);  // displaying empty stack
        System.out.println(" Displaying the top element using peek method : " + stack.peek());  // using peek() method
         }  
}

Output:

search() method in the Stack class :

For searching any element in the stack search() method is used. It returns the  distance of the element from the top. Here stack index starts from 1, not 0. If a stack contains similar elements, then it returns the index of the nearest element to the top. If the element is not present in the stack, then it returns "-1".

SearchMethodExample.java

import java.util.*;  
public class SearchMethodExample {  
    public static void main(String[] args) {  
        Stack<String> stack = new Stack<String>();  // creating empty stack
        stack.push(" Hello ");  // adding elements to the stack
        stack.push(" programmers");  
        stack.push(" Welcome ");  
        stack.push(" To ");  
        stack.push(" JavaTpoint ");  
        System.out.println("The stack is: " + stack);  // displaying the stack
        System.out.println(" Hello is present at? " + stack.search(" Hello "));  // searching the element
        System.out.println(" To is present at? " + stack.search(" To ")); 
  System.out.println(" Java is present at? " + stack.search("Java"));  // searching for an element which is not present in the stack
 }  
}

Output :

empty() method in Stack class :

An empty () method in Java is used to check whether the stack is empty or not. It is like a Boolean type. If the stack is empty, It returns true, or else it returns false. Arguments are not allowed in this method.

EmptyMethodExample.java

import java.util.*;  
public class EmptyMethodExample {  
    public static void main(String[] args) {  
        Stack<String> stack = new Stack<String>();  // empty stack is created
        System.out.println("Is the stack empty? " + stack.empty());  // returns true
    }  
}

Output :