Implementations

An array stack keeps an int[] and a size: the top is data[size - 1]. Push writes at size and increments it; pop decrements it. Growing by doubling keeps push amortised O(1). Memory is compact and cache friendly.

Step through pushes and pops in the animation to see the array and size.

1class ArrayStack {
2    private int[] data = new int[4];
3    private int size;
4    void push(int x) {
5        if (size == data.length) data = Arrays.copyOf(data, size * 2);
6        data[size++] = x;
7    }
8    int pop() {
9        if (size == 0) throw new NoSuchElementException("stack underflow");
10        return data[--size];
11    }
12    int peek() {
13        if (size == 0) throw new NoSuchElementException("stack underflow");
14        return data[size - 1];
15    }
16    boolean isEmpty() { return size == 0; }
17}

1class ArrayStack {
2    private int[] data; private int size;
3    ArrayStack(int capacity) { data = new int[capacity]; }
4    void push(int x) {
5        if (size == data.length) data = Arrays.copyOf(data, data.length * 2);   // resizable; a fixed stack rejects instead
6        data[size++] = x;
7    }
8    int pop() {
9        if (size == 0) throw new NoSuchElementException("stack underflow");
10        return data[--size];
11    }
12    int peek() {
13        if (size == 0) throw new NoSuchElementException("stack underflow");
14        return data[size - 1];                      // look without removing
15    }
16    boolean isEmpty() { return size == 0; }
17}

A linked-list stack makes the top the head of a singly linked list: push inserts a new head, pop removes the head. Every operation is a true O(1) with no resizing, but each element costs a node object and the nodes are scattered in memory. It never needs to copy elements and never wastes spare capacity.

Use it when worst-case O(1) per operation matters more than speed and memory.

1class LinkedStack {
2    private static class Node { int val; Node next; Node(int v, Node n) { val = v; next = n; } }
3    private Node top;
4    void push(int x) { top = new Node(x, top); }
5    int pop() {
6        if (top == null) throw new NoSuchElementException("stack underflow");
7        int v = top.val; top = top.next; return v;
8    }
9    boolean isEmpty() { return top == null; }
10}

java.util.ArrayDeque is the standard stack in modern Java: a resizable circular array with O(1) amortised operations at both ends. Use it through the Deque interface: push, pop and peek work at the front (the top). It rejects null elements and is not thread-safe. It is usually faster than both Stack and LinkedList.

Declare the variable as Deque so the implementation can change.

1Deque<Integer> stack = new ArrayDeque<>();
2stack.push(1); stack.push(2); stack.push(3);
3int top = stack.peek();        // 3
4int popped = stack.pop();      // 3
5boolean empty = stack.isEmpty();

java.util.Stack extends Vector, so it inherits dozens of unrelated list methods (such as add(index, e) and get(i)) that break the LIFO contract, and every method is synchronised, which costs time you rarely need. Its push adds at the end, so iteration order is bottom to top, the opposite of ArrayDeque. The JDK documentation itself recommends Deque implementations instead.

Use ArrayDeque unless you are maintaining old code.

1Stack<Integer> legacy = new Stack<>();
2legacy.push(1); legacy.push(2);
3System.out.println(legacy);                 // [1, 2]: bottom to top
4legacy.add(0, 99);                          // allowed, and violates the idea of a stack
5Deque<Integer> modern = new ArrayDeque<>();
6modern.push(1); modern.push(2);
7System.out.println(modern);                 // [2, 1]: top first