Further, it provides only a default constructor to create an empty stack object.

One of the main use case of the Stack class is to reverse a sequence of elements. This can be done by pushing elements onto the stack and then popping them off one by one from the top.

The collection class provides various methods for manipulating elements present in the stack, such as push(), pop(), peek(), and empty().

Methods Of Stack Class

push(): The push method is used to add an element to the top of the stack

pop(): The pop method is used to remove and return the element at the top.

peek(): The peek method returns the element at the top without removing it.

empty(): It returns true if the stack is empty, otherwise, false.

search(): It searches an element, and returns offset, otherwise, -1 to signify not found.

Other Inherited Methods

Here’s a program example to reverse a sequence of integers using Stack:

Program: 

import java.util.Stack;

public class Main
{
  public static void main (String[]args)
  {
    Stack < Integer > stack = new Stack <> ();
    stack.push (1);
    stack.push (2);
    stack.push (3);
    stack.push (4);
    while (!stack.empty ())
      {
  System.out.println ("Element :: "+ stack.pop ());
      }
  }
}

Output:

Element :: 4
Element :: 3
Element :: 2
Element :: 1

Over Stack class, the Deque interface should be used as it provides a more complete and flexible API. The Deque interface extends the Queue interface and supports both LIFO and First-In-First-Out (FIFO) operations. The ArrayDeque class implements the Deque interface which is a resizable array and is a good choice for most use cases.

import java.util.ArrayDeque;
public class Main
{
  public static void main (String[]args)
  {
    ArrayDeque < Integer > deque = new ArrayDeque <> ();
    deque.push (1);
    deque.push (2);
    deque.push (3);
    deque.push (4);
    while (!deque.isEmpty ())
      {
  System.out.println ("Element :: "+deque.pop ());
      }
  }
}

Element :: 4
Element :: 3
Element :: 2
Element :: 1

A stack is a data structure that works in LIFO ( Last in First out) manner. Data can be inserted with push operation and deleted using pop operation, only from one end called Top.

Java program to implement Stack using Custom Implementation

Program:

import java.util.Scanner;
class StackExample {
    int number[];
    int top;
    int limit;

    // constructor
    public StackExample(int size){
        top =-1;
        limit =size;
        number=new int[size];
    }
    // insert an element
    void push(int num)
    {
        if(isFull())
            System.out.println("Stack is full");
        else
        {
            top=top+1;
            number[top]=num;
        }

    }
    // popping out the element that is at the top of stack
    void pop(){
        if(isEmpty())
            System.out.println("Stack is Empty");
        else{
            top=top-1;
            System.out.println("Element popped out");
        }
    }
    void peek()
    {
        System.out.println("Top most element in Stack ="+number[top]);

    }
    // check stack, is it full or not?
    boolean isFull(){
        return top >=limit-1;
    }
    boolean isEmpty(){
        return top==-1;
    }

    void print(){
        System.out.println("Elements in Stack:-");
        for(int i=top;i>=0;i--)
            System.out.println(number[i]);
    }


    public static void main(String[] args) {
        Scanner input =new Scanner(System.in) ;
        int size,option,element;
        char chr;
        System.out.print("Enter the maximum size that a stack can have = ");
        size=input.nextInt();
        StackExample obj= new StackExample(size);
        do{
            System.out.println("Please press any number from the following operations:-"
                    + "\n 1. Insert an element "
                    + "\n 2. Pop an element"
                    + "\n 3. Peek of the stack"
                    + "\n 4. Display the elements of the stack");
            option=input.nextInt();

            switch(option){
                case 1:
                    System.out.print("Please enter the element to insert = ");
                    element=input.nextInt();
                    obj.push(element);
                    break;
                case 2:
                    obj.pop();
                    break;
                case 3:
                    obj.peek();
                    break;
                case 4:
                    obj.print();
                    break;
                default:
                    System.out.println("Choose wrong option ");

            }
            System.out.println("Want to continue? y or n ");
            chr=input.next().charAt(0);
        }while(chr=='y'||chr=='Y');
    }
}

Output:

Java program to implement Stack using Stack Class

Java supports a predefined class named Stack. It offers methods like push(), pop() and peek() that helps in achieving stack implementation

Program: 

import java.util.Stack;

class StackExample {
    public static void main(String[] args) {
        Stack<Integer> integerStack = new Stack<>();
        // Pushing 5 element into the stack
        integerStack.push(34);
        integerStack.push(2);
        integerStack.push(5);
        integerStack.push(100);
        integerStack.push(2);

        // printing the stack's elements
        System.out.println("Elements in the Stack :: " + integerStack);

        // Pop operation on the stack, 2 would be removed from the top
        integerStack.pop();

        // printing the stack's elements
        System.out.println("Elements in the Stack :: " + integerStack);

        // Peek operation on the stack,100 would be printed
        System.out.println("Top of the stack :: " + integerStack.peek());
    }
}

Output:

Elements in the Stack :: [34, 2, 5, 100, 2]
Elements in the Stack :: [34, 2, 5, 100]
Top of the stack :: 100

How are Java Objects Stored in Memory?

In Java, creation of an object is a two-step procedure where we first declare an object of that class type and then a physical copy of the actual object of the class is assigned to that variable.

This assignment of an actual copy of the object is done by using ‘new keyword’ for dynamic allocation of memory. A ‘new keyword’ allocates memory in heap and a reference to the allocated object which is nothing but an address is stored in the variable of the respective reference type.

Syntax:

Myclass obj;   //  Not an object, just a reference variable 

Obj = new Myclass(); // instantiation and initialization object

•  A reference variable is created and used to store the address of an object.
• A ‘new keyword’ paired with a constructor is used to assign the reference variable, this is how instantiation and initialization of an object take place. Instantiation of an object is done by new, whereas Initialization is by the constructor of that class. A constructor initializes the newly created objects.

Each time when an object is declared, it is said to be an instance of a class is created.

An object gets memory on the heap. In stack memory, the variable of class type stores the address of an object.

In heap memory, a physical copy of an object is stored and the reference or address of this copy in the variable of the associated class. Objects that can no longer be referenced are cleaned up by Garbage collector.

Java program to demonstrate the working of object

class myclass{
void display(){

System.out.println("I am printing");
}

}
public class Sample1 {

public static void main(String[] args) {
myclass obj;
obj= new myclass();
obj.display();
}

}

Output:

I am printing