What is Type Erasure in Java: Explanation and Example

In Java, type erasure is the process where generic type information is removed during compilation, so the compiled code works with raw types. This means that generic types like List<String> lose their specific type information at runtime, ensuring backward compatibility with older Java versions.

How It Works

Type erasure happens during Java compilation. Imagine you write code using generic types like List<String>. The compiler replaces these specific types with a general type, usually Object, and inserts casts where needed. This way, the compiled program does not keep track of the specific types at runtime.

Think of it like a cookie cutter: you shape dough into different cookie shapes (types) when writing code, but after baking (compiling), all cookies look the same (raw types) to the oven (Java runtime). This keeps Java backward compatible with older code that does not use generics.

Example

This example shows a generic class and how type erasure affects it at runtime.

java

import java.util.ArrayList;
import java.util.List;

public class TypeErasureExample {
    public static void main(String[] args) {
        List<String> stringList = new ArrayList<>();
        List<Integer> intList = new ArrayList<>();

        // Both lists have the same class at runtime due to type erasure
        System.out.println("stringList class: " + stringList.getClass());
        System.out.println("intList class: " + intList.getClass());

        // This shows that both are the same class
        System.out.println("Are classes equal? " + (stringList.getClass() == intList.getClass()));
    }
}

Output

stringList class: class java.util.ArrayList
intList class: class java.util.ArrayList
Are classes equal? true

When to Use

Type erasure is not something you use directly; it is a behind-the-scenes feature of Java generics. It allows you to write flexible, type-safe code without losing compatibility with older Java versions.

Use generics to catch type errors at compile time and write reusable code. Understanding type erasure helps when you face limitations, such as not being able to create generic arrays or check generic types at runtime.

For example, when writing collections or utility classes that work with different data types, generics with type erasure let you do this safely and efficiently.

Key Points

• Type erasure removes generic type info during compilation.
• It ensures backward compatibility with older Java versions.
• Generic types are replaced with raw types like Object.
• Runtime does not know the specific generic types used.
• This causes some limitations, like no generic array creation.

Key Takeaways

Type erasure removes generic type details at compile time in Java.

It allows generics to work without changing the runtime behavior.

Generics improve type safety but lose type info at runtime due to erasure.

Understanding type erasure helps explain some generic limitations.

Both List and List have the same runtime class.