DEV Community

Mohammed mhanna
Mohammed mhanna

Posted on • Edited on

🧠 Mastering Data Structures in Java — Part 4: Stack

#java #programming #architecture #performance

🔍 What Is a Stack?

A Stack is a Last-In, First-Out (LIFO) data structure.
This means the last element added is the first one to be removed — just like a stack of plates 🍽️.

👉 You can only access the top plate (element) at any given time.

In Java, the Stack is part of the java.util package:

import java.util.Stack;
Enter fullscreen mode Exit fullscreen mode

⚙️ Example: Using Stack in Java

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<String> browserHistory = new Stack<>();

        browserHistory.push("Google");
        browserHistory.push("YouTube");
        browserHistory.push("GitHub");

        System.out.println(browserHistory); // [Google, YouTube, GitHub]

        System.out.println("Top: " + browserHistory.peek()); // GitHub

        browserHistory.pop();
        System.out.println("After back: " + browserHistory); // [Google, YouTube]
    }
}
Enter fullscreen mode Exit fullscreen mode

🧩 Operations:

push() → Add element to top

pop() → Remove top element

peek() → View top element

empty() → Check if stack is empty

search() → Find position of an element

⚙️ Internal Working

Under the hood, Java’s Stack class extends Vector, so it’s synchronized and thread-safe, but slower in single-threaded contexts.

A modern alternative is Deque, which provides faster stack operations:

import java.util.ArrayDeque;

Deque<Integer> stack = new ArrayDeque<>();
stack.push(10);
stack.push(20);
System.out.println(stack.pop()); // 20
Enter fullscreen mode Exit fullscreen mode

🧠 Use ArrayDeque instead of Stack for better performance.

Operation Time Complexity
Push O(1)
Pop O(1)
Peek O(1)
Search O(n)

💡 Real-World Uses of Stack

Stacks are everywhere in computer science. Here are a few real-world scenarios:

🧾 1. Undo/Redo Mechanisms

Applications like text editors use stacks to track user actions.

  • Undo Stack stores previous states.
  • Redo Stack re-applies undone actions.

🌐 2. Browser Navigation

Every time you visit a page, it’s pushed onto the stack.
When you click “Back,” it pops the last page and shows the previous one.

🧮 3. Expression Evaluation

Stacks are used in:

Converting infix to postfix expressions

Evaluating arithmetic expressions
Example: (3 + 5) * 2 → Processed using stacks.

💻 4. Function Call Stack

Each method call is pushed onto the call stack.
When the method finishes, it’s popped off. This is handled automatically by the JVM.

🔁 5. DFS Algorithms

Depth-First Search (DFS) in graphs uses a stack to keep track of visited nodes.

⚠️ Common Mistakes

❌ Forgetting that Stack is synchronized → may impact performance.

❌ Using Stack where ArrayDeque is better.

❌ Popping from an empty stack → throws EmptyStackException.

Feature Stack
Principle LIFO
Core Operations push(), pop(), peek()
Performance O(1) for most
Implementation Vector (synchronized) or ArrayDeque (recommended)
Best For Backtracking, undo systems, expression parsing, recursion tracking

🧠 Final Thought

A Stack is one of the simplest yet most powerful data structures.
It represents how programs manage memory, logic, and state.
Once you understand stacks, you understand recursion, backtracking, and control flow — all critical to becoming an advanced Java developer. 💪

Top comments (0)