泛型信息只存在于代码编译阶段，在进入 JVM 之前，与泛型相关的信息会被擦除掉。

引入泛型的目的：
Generics were introduced to the Java language to provide tighter type checks at compile time and to support generic programming.

为了实现泛型，Java编译器进行了在编译的时候会进行类型擦除：

• Replace all type parameters in generic types with their bounds or Object if the type parameters are unbounded. The produced bytecode, therefore, contains only ordinary classes, interfaces, and methods.
• Insert type casts if necessary to preserve type safety.
• Generate bridge methods to preserve polymorphism in extended generic types.

Type erasure ensures that no new classes are created for parameterized types; consequently, generics incur no runtime overhead.

Erasure of Generic Types

unbound

public class Node<T> {

    private T data;
    private Node<T> next;

    public Node(T data, Node<T> next) {
        this.data = data;
        this.next = next;
    }

    public T getData() { return data; }
    // ...
}

类型擦除之后：

public class Node {

    private Object data;
    private Node next;

    public Node(Object data, Node next) {
        this.data = data;
        this.next = next;
    }

    public Object getData() { return data; }
    // ...
}

bound

public class Node<T extends Comparable<T>> {

    private T data;
    private Node<T> next;

    public Node(T data, Node<T> next) {
        this.data = data;
        this.next = next;
    }

    public T getData() { return data; }
    // ...
}

类型擦除之后：

public class Node {

    private Comparable data;
    private Node next;

    public Node(Comparable data, Node next) {
        this.data = data;
        this.next = next;
    }

    public Comparable getData() { return data; }
    // ...
}

注意经过类型擦除之后，Node<T>变为Node，Comparable<T>变为Comparable。

Erasure of Generic Methods

unbound

// Counts the number of occurrences of elem in anArray.
//
public static <T> int count(T[] anArray, T elem) {
    int cnt = 0;
    for (T e : anArray)
        if (e.equals(elem))
            ++cnt;
        return cnt;
}

类型擦除之后：

public static int count(Object[] anArray, Object elem) {
    int cnt = 0;
    for (Object e : anArray)
        if (e.equals(elem))
            ++cnt;
        return cnt;
}

bound

假设有如下类定义：

class Shape { /* ... */ }
class Circle extends Shape { /* ... */ }
class Rectangle extends Shape { /* ... */ }

public static <T extends Shape> void draw(T shape) { /* ... */ }

类型擦除之后变为：

public static void draw(Shape shape) { /* ... */ }

Effects of Type Erasure and Bridge Methods

类型擦除可能会导致一些你没有预料到的情况，比如下面这个例子：

有下面两个类：

public class Node<T> {

    public T data;

    public Node(T data) { this.data = data; }

    public void setData(T data) {
        System.out.println("Node.setData");
        this.data = data;
    }
}

public class MyNode extends Node<Integer> {
    public MyNode(Integer data) { super(data); }

    public void setData(Integer data) {
        System.out.println("MyNode.setData");
        super.setData(data);
    }
}

下面这段代码：

MyNode mn = new MyNode(5);
Node n = mn;            // A raw type - compiler throws an unchecked warning
n.setData("Hello");     
Integer x = mn.data;    // Causes a ClassCastException to be thrown.

经过类型擦除之后会变为：

MyNode mn = new MyNode(5);
Node n = (MyNode)mn;         // A raw type - compiler throws an unchecked warning
n.setData("Hello");
Integer x = (String)mn.data; // Causes a ClassCastException to be thrown.

这段代码编译的时候并不会报错，但是这显然不合理。因为我们传进去一个String，但是在mn看来，里面存的是一个Integer。我们运行的时候会出现如下错误：

Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
    at Test.main(Test.java:10)

需要注意的是，是n.setData("Hello")抛出了ClassCastException异常，这是为什么呢？n.setData("Hello")调用的不是Node中的setData(Object data)吗？

Bridge Methods

When compiling a class or interface that extends a parameterized class or implements a parameterized interface, the compiler may need to create a synthetic method, called a bridge method, as part of the type erasure process.

在类型擦除之后，Node中的方法变为setData(Object data)，而MyNode中的方法setData(Integer data)，这两个方法的签名是不一样的，即MyNode中的setData不是对Node的setData的重写。

为了保留类型擦除之后的多态性，Java编译器会自动生成一个bridge method，使得子类的行为符合预期，如下所示：

class MyNode extends Node {

    // Bridge method generated by the compiler
    //
    public void setData(Object data) {
        setData((Integer) data);
    }

    public void setData(Integer data) {
        System.out.println("MyNode.setData");
        super.setData(data);
    }

    // ...
}

这就可以理解上面的代码为什么编译的时候不会报错，而执行的时候会抛出异常了（相当于执行了以下代码）。

Integer i = (Integer)(Object) "Hello";

Restrictions on Generics

Cannot Instantiate Generic Types with Primitive Types

Pair<int, char> p = new Pair<>(8, 'a');  // compile-time error

可以用Java的自动装箱修改以上代码：

Pair<Integer, Character> p = new Pair<>(8, 'a');

Cannot Create Instances of Type Parameters

public static <E> void append(List<E> list) {
    E elem = new E();  // compile-time error
    list.add(elem);
}

这是很好理解的，因为你根本不知道E有哪些构造函数，有些类是没有不带参数的构造函数的，new E()不知道具体调用哪个构造函数。

可以利用反射绕过上面的问题：

public static <E> void append(List<E> list, Class<E> cls) throws Exception {
    E elem = cls.newInstance();   // OK
    list.add(elem);
}

这样我们就可以像下面这样调用append方法：

List<String> ls = new ArrayList<>();
append(ls, String.class);

Cannot Declare Static Fields Whose Types are Type Parameters

A class's static field is a class-level variable shared by all non-static objects of the class. Hence, static fields of type parameters are not allowed.
假设是允许的，就会在语义上出现混乱：

public class MobileDevice<T> {
    private static T os;

    // ...
}

MobileDevice<Smartphone> phone = new MobileDevice<>();
MobileDevice<Pager> pager = new MobileDevice<>();
MobileDevice<TabletPC> pc = new MobileDevice<>();

因为os是被phone、pager和pc共享的，那现在os的具体类型是什么呢？

Cannot Use Casts or instanceof with Parameterized Types

Because the Java compiler erases all type parameters in generic code, you cannot verify which parameterized type for a generic type is being used at runtime:

public static <E> void rtti(List<E> list) {
    if (list instanceof ArrayList<Integer>) {  // compile-time error
        // ...
    }
}

运行的时候并没有跟踪类型参数，所以并不能区分ArrayList<Integer>和ArrayList<String>。我们能做的，最多是用unbounded wildcard来区分一个list是不是ArrayList：

public static void rtti(List<?> list) {
    if (list instanceof ArrayList<?>) {  // OK; instanceof requires a reifiable type
        // ...
    }
}

特别的，你不能强制转换为参数化的类型（除非是unbounded wildcards）：

List<Integer> li = new ArrayList<>();
List<Number>  ln = (List<Number>) li;  // compile-time error

但是像下面这种情况是可以强制转换的：

List<String> l1 = ...;
ArrayList<String> l2 = (ArrayList<String>)l1;  // OK

Cannot Create Arrays of Parameterized Types

List<Integer>[] arrayOfLists = new List<Integer>[2];  // compile-time error

我们先来看一段非泛型代码：

Object[] strings = new String[2];
strings[0] = "hi";   // OK
strings[1] = 100;    // An ArrayStoreException is thrown.

我们假设是能创建泛型数组的，我们用泛型数组做一样的事：

Object[] stringLists = new List<String>[];  // compiler error, but pretend it's allowed
stringLists[0] = new ArrayList<String>();   // OK
stringLists[1] = new ArrayList<Integer>();  // An ArrayStoreException should be thrown, but the runtime can't detect it.

如果可以创建泛型数组，上面的代码就会如法抛出ArrayStoreException异常。

Cannot Create, Catch, or Throw Objects of Parameterized Types

泛型类不能直接或间接继承Throwable：

// Extends Throwable indirectly
class MathException<T> extends Exception { /* ... */ }    // compile-time error

// Extends Throwable directly
class QueueFullException<T> extends Throwable { /* ... */ // compile-time error

不能捕获类型参数实例：

public static <T extends Exception, J> void execute(List<J> jobs) {
    try {
        for (J job : jobs)
            // ...
    } catch (T e) {   // compile-time error
        // ...
    }
}

但是可以在throws语句中使用类型参数：

class Parser<T extends Exception> {
    public void parse(File file) throws T {     // OK
        // ...
    }
}

Cannot Overload a Method Where the Formal Parameter Types of Each Overload Erase to the Same Raw Type

A class cannot have two overloaded methods that will have the same signature after type erasure.
所以下面的代码会出现编译错误：

public class Example {
    public void print(Set<String> strSet) { }
    public void print(Set<Integer> intSet) { }
}