All 15 Generics questions
More in Generics
What problem do generics solve compared to using raw types (like a pre-Java-5 List without a type parameter), and how do they improve compile-time type safety? What is type erasure, and how does it explain why generic type information is unavailable at runtime (e.g., why you can't do `if (obj instanceof List<String>)`)? How do you write a generic method (as opposed to a generic class), and how does the compiler infer the type parameter from the arguments passed at a call site? What is an unbounded wildcard (List<?>), and when is it more appropriate to use than a bounded generic method with a type parameter <T>? What is a raw type in Java, and why does the compiler still permit using them (with an unchecked warning) despite generics having been available since Java 5? How would you use a Class<T> token parameter to work around type erasure when a generic method genuinely needs runtime access to the actual type argument, such as for deserialization or reflection-based instantiation? How would you write a generic interface (like a custom Repository<T, ID> pattern common in data-access layers) and implement it for a specific entity type? How do bounded wildcards (? extends T and ? super T) work, and what does the PECS (Producer Extends, Consumer Super) mnemonic mean for choosing between them? How would you implement a generic class with multiple type parameters and bounded type parameters (like <T extends Comparable<T>>), and what does this specific bound enable? How do generics interact with arrays, and why does the JDK itself sometimes use an unsafe cast (like in ArrayList's internal implementation) to work around the inability to create generic arrays directly?
Advertisement
Back to results for “Collections”
Java › Generics

How would you implement a generic Stack<T> class from scratch, demonstrating how a self-contained generic data structure is typically structured?

Intermediate

Answer

A generic Stack<T> declares its type parameter at the class level, uses it throughout the class's internal storage (commonly a generic ArrayList<T> or array-based structure) and public API (push(T item), T pop(), T peek()), giving compile-time type safety to any code using a specific instantiation like Stack<Integer> or Stack<String>, with the exact same single class definition serving every possible element type without any code duplication.
public class Stack<T> {
    private final List<T> elements = new ArrayList<>();

    public void push(T item) { elements.add(item); }

    public T pop() {
        if (elements.isEmpty()) throw new NoSuchElementException("Stack is empty");
        return elements.remove(elements.size() - 1);
    }

    public T peek() {
        if (elements.isEmpty()) throw new NoSuchElementException("Stack is empty");
        return elements.get(elements.size() - 1);
    }

    public boolean isEmpty() { return elements.isEmpty(); }
}

Stack<String> stack = new Stack<>();
stack.push("first");
String top = stack.pop();  // returns String directly, no cast needed
Real-world example An expression-evaluation engine implements a custom generic Stack<Token> to manage operator precedence during parsing, benefiting from the same single generic Stack implementation being reusable for entirely different purposes elsewhere in the codebase (like Stack<UndoAction> for an undo feature) without any code duplication.

Common follow-ups: How would you add a generic bound to this Stack to require elements be Comparable, enabling a max() method?;What's the performance/design trade-off of backing this Stack with an ArrayList versus a raw array with manual resizing?

Collections Framework;Design Patterns in Java
All 15 Generics questions