Java Notes
HubArray IntroductionArray OperationsArray Programs — FundamentalsArray Interview QuestionsJagged Array in JavaMulti Dimensional ArrayOne Dimensional Arraybreak and continue in JavaDo-While Loop in JavaFor Loop in JavaIf-Else Statements in JavaNested Loops in JavaSwitch-Case in JavaWhile Loop in JavaJava Compilation ProcessFeatures of JavaYour First Java ProgramHistory of JavaJava EditionsJava Program StructureJDK, JRE, and JVMWhat is Java?Immutable Strings in JavaString Class in JavaString Interview QuestionsString MethodsString Programs — FundamentalsStringBuffer in JavaStringBuilder in JavaComments in JavaData Types in JavaIdentifiers in JavaInput and Output in JavaKeywords in JavaOperators in JavaType Casting in JavaVariables in JavaAbstract Class in JavaAbstraction in JavaAnonymous Class in JavaClass and Object in JavaConstructor in JavaEncapsulation in JavaInheritance in JavaInner Class in JavaInterface in JavaMethod Overloading in JavaMethod Overriding in JavaObject Class in JavaObject Cloning in JavaOOPs IntroductionPolymorphism in Javastatic Keyword in Javasuper Keyword in Javathis Keyword in JavaWrapper Class in JavaCollections Framework OverviewCollections Practice ProgramsComparable vs Comparator in JavaGenerics in JavaIterator in JavaArrayList in JavaLinkedList in JavaStack in Java — Collections FrameworkVector in JavaHashMap in JavaHashtable in JavaLinkedHashMap in JavaTreeMap in JavaArrayDeque in JavaDeque Interface in JavaPriorityQueue in JavaHashSet in JavaLinkedHashSet in JavaTreeSet in JavaException Handling Best PracticesCustom Exceptions in JavaException Hierarchy in JavaFinally Block in JavaException Handling Introductionthrow and throws Keywords in JavaTry-Catch Block in JavaBuffered Streams in JavaByte Streams in JavaCharacter Streams in JavaDeserialization in JavaFile Class in JavaJava NIO PackageSerialization in JavaDate and Time API in Java 8Default and Static Methods in InterfacesFunctional Interface in Java 8Lambda Expression in Java 8Method Reference in Java 8Optional Class in Java 8Stream API in Java 8Creating Threads in JavaDaemon Threads in JavaExecutor Framework in JavaInter-Thread Communication in JavaMultithreading Programs in JavaRunnable Interface in JavaSynchronization in JavaThread Class in JavaThread IntroductionThread Life Cycle in JavaThread Priority in JavaBatch Processing in JDBCCallableStatement in JDBCJDBC ArchitectureJDBC IntroductionJDBC ProjectsMySQL Connection with JDBCPreparedStatement in JDBCResultSet in JDBCStatement Interface in JDBCTransaction Management in JDBCCookies in ServletsExpression Language (EL)GenericServletHttpServletJSP IntroductionJSP Tags and JSTLMVC ArchitectureRequest and Response ObjectsServlet IntroductionServlet Life CycleSession TrackingDependency InjectionAPI GatewayConfig ServerDocker DeploymentEureka Server - Service DiscoverySpring BeansCRUD ApplicationException Handling in Spring BootJWT Authentication — Java ProgrammingREST API with Spring BootSpring SecuritySpring Boot IntroductionSpring Data JPAValidation in Spring BootSpring Core ContainerSpring Framework IntroductionDynamic Programming in JavaGraph Data Structure in JavaHashing in JavaHeap (DSA)Linked List in JavaQueue in JavaRecursion in JavaSearching Algorithms in JavaSorting Algorithms in JavaStack in Java — DSA in JavaTime ComplexityTree Data Structure in JavaAdapter Design PatternBuilder Design PatternFactory Design PatternMVC Pattern — Java ProgrammingObserver Design PatternSingleton Design PatternArray Programs — PracticeBasic Java ProgramsCollection ProgramsJDBC ProgramsMultithreading ProgramsOOP ProgramsPlacement Coding QuestionsString Programs — PracticeBanking System — Java ProgrammingChat ApplicationE-Commerce BackendEmployee Management SystemLibrary Management System — Java ProgrammingSpring Boot Fullstack ProjectStudent Management System — Java ProgrammingCoding Interview QuestionsCollections Interview QuestionsCore Java Interview QuestionsJDBC Interview QuestionsMultithreading Interview QuestionsOOPs Interview QuestionsSpring Framework Interview QuestionsJava Cheat SheetImportant Formulas & ConceptsImportant Java ProgramsQuick Revision Notes — Java ProgrammingJava Master Course - Learning Roadmap
Complete guide to Java Stack class — LIFO principle, internal working, legacy status, why ArrayDeque is preferred, methods, use cases, and interview questions.
What is a Stack?
A Stack is a data structure that follows the LIFO (Last In, First Out) principle. The last element added is the first one to be removed — like a stack of plates.
| push(C) | adds to top |
| pop() | removes from top (returns C) |
| peek() | looks at top without removing (returns C) |
Internal Working
Since Stack extends Vector, it uses a dynamic array internally:
java example
// Vector's internal structure (inherited by Stack)
protected Object[] elementData; // The array buffer
protected int elementCount; // Number of valid elements
protected int capacityIncrement; // How much to grow (0 = double)How push() Works
Example
public E push(E item) {
addElement(item); // Inherited from Vector — adds to end of array
return item;
}
// Vector.addElement():
public synchronized void addElement(E obj) {
modCount++;
ensureCapacityHelper(elementCount + 1); // Grow if needed
elementData[elementCount++] = obj;
}
How pop() Works
java example
public synchronized E pop() {
E obj;
int len = size();
obj = peek(); // Get top element
removeElementAt(len - 1); // Remove last element
return obj;
}How peek() Works
java example
public synchronized E peek() {
int len = size();
if (len == 0) throw new EmptyStackException();
return elementAt(len - 1); // Return last element without removing
}Stack Methods
Example
import java.util.Stack;
public class StackDemo {
public static void main(String[] args) {
Stack<String> stack = new Stack<>();
// push — adds to top
stack.push("First");
stack.push("Second");
stack.push("Third");
System.out.println("Stack: " + stack); // [First, Second, Third]
// peek — view top without removing
System.out.println("Peek: " + stack.peek()); // Third
// pop — remove and return top
System.out.println("Pop: " + stack.pop()); // Third
System.out.println("Pop: " + stack.pop()); // Second
System.out.println("Stack: " + stack); // [First]
// empty — check if empty
System.out.println("Empty? " + stack.empty()); // false
// search — 1-based position from top
stack.push("A");
stack.push("B");
stack.push("C");
// Stack is: [First, A, B, C] — C is top (position 1)
System.out.println("Search B: " + stack.search("B")); // 2
System.out.println("Search X: " + stack.search("X")); // -1 (not found)
// EmptyStackException
stack.clear();
try {
stack.pop(); // EmptyStackException!
} catch (java.util.EmptyStackException e) {
System.out.println("Stack is empty!");
}
}
}
Output
Push: [10, 20, 30, 40, 50] Peek: 50 Pop: 50 After pop: [10, 20, 30, 40] Search 20: 3 Search 99: -1 Empty: false Size: 4
Time Complexity
| Operation | Time Complexity | Notes |
|---|---|---|
| ----------- | :-: | --- |
push(E e) | O(1) amortized | May trigger array resize O(n) rarely |
pop() | O(1) | Remove from end of array |
peek() | O(1) | Access last element |
empty() | O(1) | Check size |
search(Object o) | O(n) | Linear search from top |
Inherited get(int) | O(1) | Random access (breaks LIFO!) |
Why Stack is Legacy — Problems
Problem 1: Extends Vector (Tight Coupling)
Stack extends Vector, inheriting ALL list methods that violate LIFO:
java example
Stack<String> stack = new Stack<>();
stack.push("A");
stack.push("B");
stack.push("C");
// These shouldn't be possible for a "stack" but they compile fine:
stack.add(0, "Inserted at bottom!"); // Breaks LIFO!
stack.get(1); // Random access!
stack.remove(0); // Remove from middle!
stack.set(1, "Modified!"); // Modify anywhere!Problem 2: Synchronized (Performance Cost)
Every method in Stack is synchronized (inherited from Vector), even in single-threaded code:
java example
// Even push() acquires a lock — unnecessary overhead!
public synchronized void addElement(E obj) { ... }Problem 3: Inheritance vs Composition
Stack uses inheritance (IS-A Vector) instead of composition (HAS-A array). This violates encapsulation.
The Modern Alternative: ArrayDeque
Java's documentation explicitly states:
*"A more complete and consistent set of LIFO stack operations is provided by the Deque interface and its implementations, which should be used in preference to this class."*
java example
// PREFERRED — Use ArrayDeque as a stack
Deque<String> stack = new ArrayDeque<>();
stack.push("A"); // addFirst
stack.push("B"); // addFirst
stack.push("C"); // addFirst
System.out.println(stack.peek()); // C (top)
System.out.println(stack.pop()); // C (removes top)
System.out.println(stack.pop()); // BComparison: Stack vs ArrayDeque
| Feature | Stack | ArrayDeque |
|---|---|---|
| Thread-safe | Yes (synchronized) | No (faster single-threaded) |
| Inheritance | Extends Vector (bloated) | Implements Deque (clean) |
| Random access | Yes (breaks abstraction) | No (proper encapsulation) |
| null elements | Allowed | NOT allowed |
| Performance | Slower (synchronization overhead) | Faster (no locking) |
| Memory | May waste space (Vector growth) | Efficient circular array |
| Recommended | No (legacy) | Yes (modern) |
Stack Use Cases
1. Expression Evaluation
Example
public static int evaluatePostfix(String expression) {
Deque<Integer> stack = new ArrayDeque<>();
String[] tokens = expression.split(" ");
for (String token : tokens) {
if (token.matches("-?\\d+")) {
stack.push(Integer.parseInt(token));
} else {
int b = stack.pop();
int a = stack.pop();
switch (token) {
case "+": stack.push(a + b); break;
case "-": stack.push(a - b); break;
case "*": stack.push(a * b); break;
case "/": stack.push(a / b); break;
}
}
}
return stack.pop();
}
// "3 4 + 2 *" → (3+4)*2 = 14
System.out.println(evaluatePostfix("3 4 + 2 *")); // 14
2. Balanced Parentheses
Example
public static boolean isBalanced(String expression) {
Deque<Character> stack = new ArrayDeque<>();
Map<Character, Character> pairs = Map.of(')', '(', '}', '{', ']', '[');
for (char c : expression.toCharArray()) {
if ("({[".indexOf(c) != -1) {
stack.push(c);
} else if (")}]".indexOf(c) != -1) {
if (stack.isEmpty() || !stack.pop().equals(pairs.get(c))) {
return false;
}
}
}
return stack.isEmpty();
}
System.out.println(isBalanced("{[()]}")); // true
System.out.println(isBalanced("{[(])}")); // false
System.out.println(isBalanced("((())")); // false
3. Undo/Redo Mechanism
java example
public class TextEditor {
private StringBuilder text = new StringBuilder();
private Deque<String> undoStack = new ArrayDeque<>();
private Deque<String> redoStack = new ArrayDeque<>();
public void type(String s) {
undoStack.push(text.toString());
redoStack.clear();
text.append(s);
}
public void undo() {
if (!undoStack.isEmpty()) {
redoStack.push(text.toString());
text = new StringBuilder(undoStack.pop());
}
}
public void redo() {
if (!redoStack.isEmpty()) {
undoStack.push(text.toString());
text = new StringBuilder(redoStack.pop());
}
}
public String getText() { return text.toString(); }
}4. Browser History
java example
public class BrowserHistory {
private Deque<String> backStack = new ArrayDeque<>();
private Deque<String> forwardStack = new ArrayDeque<>();
private String currentPage;
public void visit(String url) {
if (currentPage != null) backStack.push(currentPage);
currentPage = url;
forwardStack.clear();
}
public String back() {
if (backStack.isEmpty()) return currentPage;
forwardStack.push(currentPage);
currentPage = backStack.pop();
return currentPage;
}
public String forward() {
if (forwardStack.isEmpty()) return currentPage;
backStack.push(currentPage);
currentPage = forwardStack.pop();
return currentPage;
}
}Thread-Safe Stack Alternatives
java example
// Option 1: ConcurrentLinkedDeque (non-blocking)
Deque<String> concurrentStack = new ConcurrentLinkedDeque<>();
concurrentStack.push("item");
concurrentStack.pop();
// Option 2: Synchronized wrapper
Deque<String> syncStack = Collections.synchronizedDeque(new ArrayDeque<>());
// Note: synchronizedDeque is not available — use synchronizedList or explicit lock
// Option 3: Explicit locking
private final Lock lock = new ReentrantLock();
private final Deque<String> stack = new ArrayDeque<>();
public void push(String item) {
lock.lock();
try { stack.push(item); }
finally { lock.unlock(); }
}Common Mistakes
1. Using Stack When ArrayDeque is Better
java example
// LEGACY — don't use
Stack<Integer> stack = new Stack<>();
// MODERN — use this
Deque<Integer> stack = new ArrayDeque<>();2. Not Checking for Empty Before pop/peek
java example
// WRONG — may throw EmptyStackException or NoSuchElementException
String top = stack.pop();
// CORRECT
if (!stack.isEmpty()) {
String top = stack.pop();
}
// OR use poll()/peek() which return null instead of throwing
String top = stack.poll(); // returns null if empty3. Using Stack's List Methods
java example
Stack<String> stack = new Stack<>();
stack.push("A");
stack.push("B");
stack.add(0, "C"); // DON'T! This inserts at the bottom — breaks LIFOInterview Questions
Q1: Why is the Stack class considered legacy?
A: Because it extends Vector (inheriting unnecessary synchronized methods and list operations that break the LIFO abstraction). ArrayDeque is the recommended replacement.
Q2: What is the difference between Stack and ArrayDeque for stack operations?
A: Stack is synchronized (slower), extends Vector (exposes non-stack methods), and allows null. ArrayDeque is faster (no synchronization), properly encapsulated (Deque interface), and disallows null.
Q3: How would you implement a thread-safe stack?
A: Use ConcurrentLinkedDeque, or wrap an ArrayDeque with explicit ReentrantLock, or use the legacy Stack class (not recommended for new code).
Q4: What exception does pop() throw on an empty stack?
A: Stack.pop() throws EmptyStackException. ArrayDeque.pop() throws NoSuchElementException. Use poll() for null-return behavior.
Q5: Can you implement a stack using two queues?
A: Yes. On push, add to queue and rotate all previous elements behind it. Pop and peek then operate on the front. Or keep two queues and swap on pop.
Q6: What is the time complexity of the search() method in Stack?
A: O(n) — it performs a linear scan from the top of the stack. Returns a 1-based position (top = 1) or -1 if not found.
Summary
| Aspect | Stack (Legacy) | ArrayDeque (Modern) |
|---|---|---|
| Use for new code | ❌ No | ✅ Yes |
| Thread-safe | Yes (but costly) | No (wrap if needed) |
| API cleanliness | Poor (inherits Vector) | Clean (Deque only) |
| Performance | Slower | Faster |
| Null support | Yes | No |
| Key operations | push, pop, peek, search | push, pop, peek |
Bottom line: Always use Deque<E> stack = new ArrayDeque<>() for stack operations in new code.
Q8: Why is Stack class considered legacy/deprecated in practice?
A: Stack extends Vector, inheriting all its synchronized overhead even in single-threaded scenarios. It also inherits List methods like get(index) which violate LIFO semantics. Java docs recommend ArrayDeque for stack operations — it's faster and properly restricts access to top-of-stack operations only.
Q9: What is the difference between Stack.push() and Vector.add()?
A: push() adds to the top (end) of the stack and returns the element pushed. add() (inherited from Vector/List) adds to the end and returns boolean. Functionally similar, but push() is the proper stack operation and makes code intent clearer.
Q10: How does Stack.search() work?
A: search(Object) returns the 1-based position from the top of the stack. The top element has position 1, the one below it has position 2, etc. Returns -1 if the element is not found. It uses equals() for comparison, searching from top to bottom.
Q11: How do you implement a thread-safe stack without using the Stack class?
A: Use Collections.synchronizedList(new LinkedList<>()) with addFirst/removeFirst, or better: use ConcurrentLinkedDeque from java.util.concurrent which provides lock-free thread-safe stack operations (push/pop/peek).
Q12: What are real-world use cases of Stack data structure?
A: (1) Undo/Redo operations in editors, (2) Browser back/forward navigation, (3) Expression evaluation and parsing (postfix, infix conversion), (4) Function call stack (recursion), (5) Balanced parentheses checking, (6) Depth-First Search (DFS) in graphs.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Stack in Java — Collections Framework.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.
Search Terms
java-master-course, java master course, java, master, course, collections, framework, list
Related Java Master Course Topics
Continue learning this concept
Collections FrameworkArrayList in JavaLearn ArrayList in Java from the ground up with clear explanations, practical examples, internal working, performance analysis, common pitfalls, and interview-focused insights designed for students and developers.Collections FrameworkLinkedList in JavaComplete guide to Java LinkedList — internal working with doubly-linked nodes, performance analysis, Deque operations, comparison with ArrayList, and when to use LinkedList.Collections FrameworkVector in JavaComplete guide to Java Vector — synchronized dynamic array, internal resizing, legacy status, comparison with ArrayList, thread safety analysis, and migration guide.Collections FrameworkCollections Framework OverviewComplete guide to Java Collections Framework covering hierarchy, interfaces, implementations, algorithms, and choosing the right collection for your use case.Collections FrameworkCollections Practice ProgramsComprehensive Java Collections practice programs covering List, Set, Map, Queue operations with solutions, explanations, and time complexity analysis.Collections FrameworkComparable vs Comparator in JavaDeep dive into Comparable and Comparator interfaces in Java — natural ordering, custom sorting, lambda expressions, method references, and practical comparisons with examples.