Generics: erasure, invariance, and wildcards

Generics let the compiler check element types: a List<String> refuses an Integer at compile time, and reading from it needs no cast. That checking happens only at compile time. The compiler then erases the type arguments: at runtime there is one ArrayList class, and a List<String> and a List<Integer> are indistinguishable.

Erasure is why you cannot write new T() or new T[n], why obj instanceof List<String> on a plain Object does not compile (the runtime has no type argument to check), and why a class cannot overload void f(List<String>) with void f(List<Integer>) — after erasure both are f(List).

Invariance, and the array that is not

Integer is a subtype of Number, but List<Integer> is not a subtype of List<Number>. If it were, this would compile:

List<Integer> ints = new ArrayList<>();
List<Number> nums = ints;    // does not compile — and this is why:
nums.add(3.14);              // a Double inside a List<Integer>

Arrays made the opposite choice long before generics existed: an Integer[] is a Number[]. The hole is then caught at runtime instead, with an ArrayStoreException.

1import java.util.*;2 3public class Solution {4    public static List<String> describe() {5        List<String> strings = new ArrayList<>();6        List<Integer> ints = new ArrayList<>();7        String sameClass = "same runtime class: " + (strings.getClass() == ints.getClass())8            + " (" + strings.getClass().getName() + ")";9 10        Integer[] boxes = new Integer[2];11        Number[] view = boxes;          // compiles: arrays are covariant12        String store;13        try {14            view[0] = 3.14;              // a Double into an Integer[]15            store = "stored";16        } catch (ArrayStoreException e) {17            store = "ArrayStoreException: " + e.getMessage();18        }19        return List.of(sameClass, store);20    }21}

Wildcards: accepting more than one type

Invariance makes naive signatures too strict. double max(List<Number> xs) cannot be called with a List<Integer>. Wildcards fix that:

• List<? extends Number> — "a list of some subtype of Number". You can read Numbers out of it, but you cannot add anything (except null), because the compiler does not know which subtype it holds.
• List<? super Integer> — "a list of Integer or some supertype". You can add Integers to it, but what you read back is only known to be an Object.

The rule of thumb is PECS: producer extends, consumer super. A parameter you only take values from is a producer; one you only put values into is a consumer. Collections.copy(List<? super T> dest, List<? extends T> src) is the textbook signature.

1import java.util.*;2 3public class Solution {4    // Reads Numbers from any list of a Number subtype.5    static double max(List<? extends Number> xs) {6        double best = Double.NEGATIVE_INFINITY;7        for (Number n : xs) best = Math.max(best, n.doubleValue());8        return best;9    }10 11    // Writes Integers into any list that can hold them.12    static void addRange(List<? super Integer> sink, int from, int to) {13        for (int i = from; i <= to; i++) sink.add(i);14    }15 16    public static List<String> describe() {17        List<Number> numbers = new ArrayList<>(List.of(0.5));18        List<Object> anything = new ArrayList<>(List.of("start"));19        addRange(numbers, 1, 3);20        addRange(anything, 7, 8);21        return List.of(22            "numbers=" + numbers + " max=" + max(numbers),23            "anything=" + anything,24            "max of List<Integer>=" + max(List.of(4, 9, 5)));25    }26}

Bounded type parameters use the same idea on a method's own type variable: <T extends Comparable<? super T>> T max(List<? extends T> xs) accepts any type that can compare itself — including a class that inherits compareTo from its parent.

Common mistakes

• Using a raw type (List with no type argument). The compiler only warns, and an element of the wrong type travels through the program until a cast the compiler inserted fails somewhere else — heap pollution.
• Declaring a parameter List<Object> to mean "any list". It accepts only a List<Object>; List<?> is the "any list" type.
• Writing List<? extends T> for a parameter you need to add to — it will not compile; that parameter is a consumer and wants ? super T.

1import java.util.*;2 3public class Solution {4    @SuppressWarnings({"rawtypes", "unchecked"})5    static void addLegacy(List list) {6        list.add(42);                      // no check: raw type7    }8 9    public static List<String> describe() {10        List<String> names = new ArrayList<>(List.of("ana"));11        addLegacy(names);12        List<String> out = new ArrayList<>();13        out.add("size=" + names.size());14        try {15            String second = names.get(1);  // the compiler inserted a cast here16            out.add("read " + second);17        } catch (ClassCastException e) {18            out.add("ClassCastException when reading index 1");19        }20        return out;21    }22}

What interviewers ask

• What is type erasure, and what can't you do because of it? Type arguments exist only at compile time; you cannot create T or T[], test an Object with instanceof List<String>, or overload on type arguments.
• Why is List<Integer> not a List<Number>? Because the latter lets you add a Double; arrays allow it and pay with ArrayStoreException at runtime.
• Explain PECS with an example. Collections.max(Collection<? extends T> coll, Comparator<? super T> comp): the collection only produces Ts, so extends; the comparator only consumes them, so super — a Comparator<Object> can then pick the max of a List<String>.