Stack Class in Java

Java Collection framework provides a Stack class that models and implements a Stack data structure. The class is based on the basic principle of last-in-first-out. In addition to the basic push and pop operations, the class provides three more functions of empty, search, and peek. The class can also be said to extend Vector and treats the class as a stack with the five mentioned functions. The class can also be referred to as the subclass of Vector.

The below diagram shows the hierarchy of the Stack class: 

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

Declaration:

public class Stack<E> extends Vector<E>

All Implemented Interfaces:

• Serializable: It is a marker interface that classes must implement if they are to be serialized and deserialized.
• Cloneable: This is an interface in Java which needs to be implemented by a class to allow its objects to be cloned.
• Iterable<E>: This interface represents a collection of objects which is iterable — meaning which can be iterated.
• Collection<E>: A Collection represents a group of objects known as its elements. The Collection interface is used to pass around collections of objects where maximum generality is desired.
• List<E>: The List interface provides a way to store the ordered collection. It is a child interface of Collection.
• RandomAccess: This is a marker interface used by List implementations to indicate that they support fast (generally constant time) random access.

How to Create a Stack?

In order to create a stack, we must import java.util.stack package and use the Stack() constructor of this class. The below example creates an empty Stack.

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

Here E is the type of Object.

Example: 

Output:

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

Performing various operations on Stack class

1. Adding Elements: In order to add an element to the stack, we can use the push() method. This push() operation place the element at the top of the stack.

 Output:

[4, All, Geeks]
[Geeks, For, Geeks]

2. Accessing the Element: To retrieve or fetch the first element of the Stack or the element present at the top of the Stack, we can use peek() method. The element retrieved does not get deleted or removed from the Stack. 

Output:

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. Removing Elements: To pop an element from the stack, we can use the pop() method. The element is popped from the top of the stack and is removed from the same.

Output:

Initial Stack: [10, 15, 30, 20, 5]
Popped element: 5
Popped element: 20
Stack after pop operation [10, 15, 30]

Example

In Java, the Stack class is a subclass of the Vector class and represents a last-in-first-out (LIFO) stack of objects. It extends the Vector class to allow for easy implementation of the stack data structure.

Here’s an example of how you can use the Stack class in Java:

4
3
2
1

In this example, we first import the Stack class from the java.util package. We then create a new Stack object called stack using the default constructor. We push four integers onto the stack using the push() method. We then pop the elements from the stack using the pop() method inside a while loop. The isEmpty() method is used to check if the stack is empty before attempting to pop an element.

This code creates a stack of integers and pushes 4 integers onto the stack in the order 1 -> 2 -> 3 -> 4. We then pop elements from the stack one by one using the pop() method, which removes and returns the top element of the stack. Since the stack follows a last-in-first-out (LIFO) order, the elements are popped in the reverse order of insertion, resulting in the output shown above.

The Stack class provides several other methods for manipulating the stack, such as peek() to retrieve the top element without removing it, search() to search for an element in the stack and return its position, and size() to return the current size of the stack. The Stack class also provides several constructors for creating a stack with a specified initial capacity or by copying an existing stack.

 Methods in Stack Class 

Methods inherited from class java.util.Vector

Prioritize use of  Deque over Stack -:

The Stack class in Java is a legacy class and inherits from Vector in Java. It is a thread-safe class and hence involves overhead when we do not need thread safety. It is recommended to use ArrayDeque for stack implementation as it is more efficient in a single-threaded environment.

Output: 

B
B

One more reason to use Deque over Stack is Deque has the ability to use streams convert to list with keeping LIFO concept applied while Stack does not.

Using Stack -
1 2 
Using Deque -
2 1