Type Erasure & Generics Pitfalls

List rawList = new ArrayList<String>();
rawList.add(42);                         // no warning with raw type
String s = (String) rawList.get(0);      // ClassCastException at runtime!

What is Type Erasure?

Type erasure is the process by which the Java compiler removes all generic type information at compile time and inserts explicit casts where needed. At the bytecode level, generics do not exist.

Why? Backward compatibility. Generics were added in Java 5 but had to interoperate with pre-generics code (erasure-based implementation avoids breaking the JVM).

Before / After Erasure

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
flowchart LR
    subgraph COMPILE["Compile Time"]
        style COMPILE fill:#DBEAFE,stroke:#93C5FD,color:#1E40AF
        A["List<String> names"]
        B["Box<Integer> box"]
        C["T getValue()"]
    end
    subgraph RUNTIME["After Erasure"]
        style RUNTIME fill:#FEE2E2,stroke:#FCA5A5,color:#991B1B
        D["List names"]
        E["Box box"]
        F["Object getValue()"]
    end
    A --> D
    B --> E
    C --> F

Erasure Rules

// What you write
public class Box<T extends Number> {
    private T value;
    public T getValue() { return value; }
}

// What the compiler produces (after erasure)
public class Box {
    private Number value;
    public Number getValue() { return value; }
}

What You CANNOT Do with Generics

These restrictions exist because type information is erased at runtime:

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
flowchart TB
    subgraph FORBIDDEN["Cannot Do — Erased at Runtime"]
        style FORBIDDEN fill:#FEF2F2,stroke:#FCA5A5,color:#991B1B
        A["new T()"]
        B["instanceof T"]
        C["T.class"]
        D["static T field"]
        E["catch T / throw T"]
        F["new T[]"]
    end

// WRONG: Cannot instantiate T
public <T> T create() {
    return new T();  // COMPILE ERROR
}

// CORRECT: Use Class token
public <T> T create(Class<T> clazz) throws Exception {
    return clazz.getDeclaredConstructor().newInstance();
}

// CORRECT: Use Supplier (Java 8+)
public <T> T create(Supplier<T> factory) {
    return factory.get();
}

Bridge Methods

When a generic class is extended with a concrete type, the compiler generates bridge methods to preserve polymorphism after erasure.

// Generic interface
public interface Comparable<T> {
    int compareTo(T o);
}

// Concrete implementation
public class MyInt implements Comparable<MyInt> {
    private int value;

    @Override
    public int compareTo(MyInt other) {   // actual method
        return Integer.compare(this.value, other.value);
    }
}

After erasure, Comparable has compareTo(Object). But MyInt defines compareTo(MyInt). The compiler generates a bridge method:

// Compiler-generated bridge method (synthetic)
public int compareTo(Object o) {       // matches erased signature
    return compareTo((MyInt) o);       // delegates to real method with cast
}

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
flowchart LR
    subgraph CALLER["Polymorphic Call"]
        style CALLER fill:#EFF6FF,stroke:#93C5FD,color:#1E40AF
        A["comparable.compareTo(obj)"]
    end
    subgraph BRIDGE["Bridge Method"]
        style BRIDGE fill:#FEF3C7,stroke:#FCD34D,color:#92400E
        B["compareTo(Object o)\n  cast + delegate"]
    end
    subgraph REAL["Actual Method"]
        style REAL fill:#D1FAE5,stroke:#6EE7B7,color:#065F46
        C["compareTo(MyInt o)\n  real logic"]
    end
    A --> B --> C

Wildcards Deep Dive

Upper Bounded: ? extends T (Producer / Covariant)

You can read from it (produces T), but cannot write to it (compiler doesn't know the exact subtype).

// PRODUCER — reads items out
public double sum(List<? extends Number> numbers) {
    double total = 0;
    for (Number n : numbers) {   // safe: everything IS-A Number
        total += n.doubleValue();
    }
    // numbers.add(42);  // COMPILE ERROR — cannot add
    return total;
}

sum(List.of(1, 2, 3));           // List<Integer> OK
sum(List.of(1.5, 2.5));          // List<Double> OK

Lower Bounded: ? super T (Consumer / Contravariant)

You can write T into it, but reading gives you only Object.

// CONSUMER — puts items in
public void addIntegers(List<? super Integer> dest) {
    dest.add(1);        // safe: dest accepts Integer or any supertype
    dest.add(2);
    // Integer i = dest.get(0);  // COMPILE ERROR — might be Object
}

addIntegers(new ArrayList<Number>());   // OK
addIntegers(new ArrayList<Object>());   // OK

PECS: Producer Extends, Consumer Super

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
flowchart LR
    subgraph PECS["PECS Principle"]
        style PECS fill:#DBEAFE,stroke:#93C5FD,color:#1E40AF
        P["PRODUCER\n? extends T\nRead-only"]
        C["CONSUMER\n? super T\nWrite-only"]
    end
    P -->|"get()"| OUT["T out"]
    IN["T in"] -->|"add()"| C
    style OUT fill:#D1FAE5,stroke:#6EE7B7,color:#065F46
    style IN fill:#FEF3C7,stroke:#FCD34D,color:#92400E

// Classic example: Collections.copy uses PECS
public static <T> void copy(List<? super T> dest,     // consumer (super)
                             List<? extends T> src) {  // producer (extends)
    for (int i = 0; i < src.size(); i++) {
        dest.set(i, src.get(i));
    }
}

Unbounded Wildcards (?) vs Raw Types

They look similar but are fundamentally different:

// SAFE: unbounded wildcard
public void printAll(List<?> items) {
    for (Object item : items) {
        System.out.println(item);
    }
    // items.add("test");  // COMPILE ERROR (good!)
}

// UNSAFE: raw type
public void printAll(List items) {
    items.add(42);   // no error — but corrupts the list
}

Reifiable vs Non-Reifiable Types

A reifiable type retains its full type information at runtime. A non-reifiable type has some information erased.

Arrays are Reifiable — Generics are Not

Arrays carry their element type at runtime. Generics do not. This mismatch causes problems:

// Arrays: runtime type checking
Object[] objArray = new String[10];
objArray[0] = 42;        // ArrayStoreException at RUNTIME (caught!)

// Generics: NO runtime checking
List<Object> objList = (List) new ArrayList<String>();
objList.add(42);          // NO exception — heap pollution!

// This is why generic array creation is illegal:
T[] array = new T[10];              // COMPILE ERROR
List<String>[] array = new List[10]; // unchecked warning — dangerous

// Safe alternative: use List<List<String>> or Array.newInstance
@SuppressWarnings("unchecked")
T[] array = (T[]) Array.newInstance(clazz, size);

Heap Pollution

Heap pollution occurs when a variable of a parameterized type refers to an object that is NOT of that type. Common with varargs + generics.

// DANGEROUS: varargs creates Object[] internally
static <T> List<T> toList(T... elements) {
    // 'elements' is actually Object[] at runtime — heap pollution possible
    return Arrays.asList(elements);
}

// The real danger: storing into the varargs array
static <T> T[] dangerous(T... args) {
    Object[] objArray = args;      // valid: T[] erased to Object[]
    objArray[0] = "string";        // pollutes if T != String
    return args;                   // ClassCastException when caller uses T
}

Integer[] result = dangerous(1, 2, 3);  // ClassCastException!

@SafeVarargs

Use @SafeVarargs on methods that do NOT store into the varargs array:

@SafeVarargs  // safe: only reads from 'elements', never writes
static <T> List<T> toList(T... elements) {
    List<T> list = new ArrayList<>();
    for (T e : elements) {
        list.add(e);
    }
    return list;
}

Type Tokens & Super Type Tokens

Since generic types are erased, you sometimes need to pass type information explicitly.

Simple Type Token

// Pass Class<T> to retain type info at runtime
public <T> T deserialize(String json, Class<T> type) {
    return objectMapper.readValue(json, type);
}

// Usage
User user = deserialize(jsonStr, User.class);

Problem: Class<T> cannot represent parameterized types like List<String>.

Super Type Token (TypeReference Pattern)

Captures full generic type through anonymous class inheritance:

// Abstract class that captures generic type via reflection
public abstract class TypeReference<T> {
    private final Type type;

    protected TypeReference() {
        // Anonymous subclass preserves generic info in class metadata
        Type superclass = getClass().getGenericSuperclass();
        this.type = ((ParameterizedType) superclass).getActualTypeArguments()[0];
    }

    public Type getType() { return type; }
}

// Usage — anonymous class preserves List<String> in bytecode
TypeReference<List<String>> ref = new TypeReference<List<String>>() {};
Type type = ref.getType();  // java.util.List<java.lang.String>

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
flowchart TB
    subgraph TOKEN["Type Token Approaches"]
        style TOKEN fill:#EFF6FF,stroke:#93C5FD,color:#1E40AF
        A["Class<T>\nSimple types only"]
        B["TypeReference<T>\nParameterized types"]
    end
    subgraph USE["Used By"]
        style USE fill:#ECFDF5,stroke:#6EE7B7,color:#065F46
        C["Jackson\nObjectMapper"]
        D["Guice\nTypeLiteral"]
        E["Spring\nParameterizedTypeRef"]
    end
    A --> C
    B --> C
    B --> D
    B --> E

Common Pitfalls

Quick Recall

Interview Template