Stack in Java
- A stack in java is a fundamental data structure utilized in computer science and programming.
- It takes after a Last In First Out (LIFO) principle, meaning the final component inserted is the first to be removed.
- In Java, stacks are ordinarily utilized for scenarios like function calls, backtracking algorithms (e.g., in maze solving), and fix mechanisms in applications.
- Java gives an usage of stack through both its built-in classes and as part of other collections.
Types of Stack in Java
Java offers two essential ways to actualize a stack:
- The Stack class from the java.util package.
- The Deque interface, particularly with the ArrayDeque class.
1. The Stack Class
- java.util.Stack is a legacy class that’s a part of the java collection framework.
- It actualizes the List interface and gives the essential stack operations such as push, pop, peek, and empty.
- Push: adds an item onto the top of the stack.
- Pop: Removes the item from the top of the stack.
- Peek: Returns the item at the top of the stack without removing it.
- Empty: Checks in case the stack is empty.
- The Stack class was presented in prior versions of Java, but it is presently to a great extent considered out of date in favor of other collection classes due to execution and thread security concerns.
2. Deque Interface with ArrayDeque Class
- A more modern approach to executing a stack in Java is by utilizing the Deque interface, especially the ArrayDeque class.
- ArrayDeque offers a more proficient, resizable array-based execution and supports both stack and queue operations.
- Not at all like Stack, ArrayDeque isn’t synchronized, which makes it way better suited for single-threaded situations.
- The core stack operations accessible in ArrayDeque are:
- addFirst (comparable to push): Inserts an component at the front (top) of the deque.
- removeFirst (comparable to pop): Removes and returns the first component of the deque.
- peekFirst (comparable to peek): Returns the primary component of the deque without removing it.
- Whereas Deque can be utilized for actualizing both stacks and queues, it is the favored choice for stack operations due to its updated execution and adaptability.
Stack Operations with examples
Let’s see at examples for both the Stack class and ArrayDeque to prevalent get it their utilization in Java.
Example 1: Using the stack class
import java.util.Stack;
public class StackExample {
public static void main(String[] args) {
Stack<Integer> stack = new Stack<>();
// Push elements onto the stack
stack.push(10);
stack.push(20);
stack.push(30);
// Peek the top element
System.out.println("Top element: " + stack.peek()); // Output:30
// Pop elements from the stack
System.out.println("Popped element: " + stack.pop()); // Output:30
System.out.println("Popped element: " + stack.pop()); // Output:20
// Check if the stack is empty
System.out.println("Is stack empty? " + stack.isEmpty()); // Output:false
}
}
In this case, we utilized the push method to include components to the stack. The peek method is utilized to see the top component without removing it, while the pop method evacuates and returns the top component.
Example 2: Using the ArrayDeque Class
import java.util.ArrayDeque;
public class ArrayDequeStackExample {
public static void main(String[] args) {
ArrayDeque<Integer> stack = new ArrayDeque<>();
// Push elements onto the stack
stack.addFirst(10);
stack.addFirst(20);
stack.addFirst(30);
// Peek the top element
System.out.println("Top element: " + stack.peekFirst()); // Output:30
// Pop elements from the stack
System.out.println("Popped element: " + stack.removeFirst()); // Output:30
System.out.println("Popped element: " + stack.removeFirst()); // Output:20
// Check if the stack is empty
System.out.println("Is stack empty? " + stack.isEmpty()); // Output:false
}
}
In this case, we utilized the addFirst method to push components onto the stack and removeFirst to pop components. The peekFirst method returns the component at the top of the stack without evacuating it.
Choosing Between Stack and ArrayDeque
1.Stack (java.util.Stack):
- Legacy class could be a part of the java collection frameworks but not proposed for progressed applications.
- Synchronized, which can display overhead in multi-threaded circumstances.
- Gives essential stack operations but needs versatility in terms of execution.
2.ArrayDeque (java.util.ArrayDeque):
- Favored for stack operations due to its execution and dynamic size.
- Not synchronized, so prevalent suited for single-threaded applications.
- More profitable than stack for most utilize cases, especially when thread security isn’t a concern.