Java中的泛型擦除及其影响。

Java中的泛型擦除（Type Erasure）是指在编译时，Java 编译器会将泛型信息去除，使得生成的字节码不包含任何泛型相关的信息。泛型擦除是为了与之前的非泛型代码保持兼容性。

1. 泛型擦除的原理

在编译时，泛型类型参数会被替换为它的擦除类型。通常：

• 如果类型参数有一个上界（例如 <T extends Number>），它会被替换为上界类型（Number）。
• 如果类型参数没有上界，它会被替换为 Object。

例如：

public class Box<T> {
    private T value;
    
    public void setValue(T value) {
        this.value = value;
    }
    
    public T getValue() {
        return value;
    }
}

在编译后，泛型类型 T 会被擦除：

public class Box {
    private Object value;
    
    public void setValue(Object value) {
        this.value = value;
    }
    
    public Object getValue() {
        return value;
    }
}

2. 泛型擦除的影响

a. 类型信息丢失

由于类型擦除，运行时无法获取泛型的具体类型。例如，以下代码在运行时无法判断 List<String> 和 List<Integer> 的区别：

List<String> stringList = new ArrayList<>();
List<Integer> integerList = new ArrayList<>();

if (stringList.getClass() == integerList.getClass()) {
    System.out.println("同样的类型");
}

这段代码会输出“同样的类型”，因为在运行时，两者的类型信息已经被擦除，均为 List。

b. 类型安全性问题

由于类型擦除，Java 在编译时无法完全检测类型安全性，这可能导致 ClassCastException：

public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        unsafeAdd(list, Integer.valueOf(42));
        String s = list.get(0);  // 运行时会抛出 ClassCastException
    }

    private static void unsafeAdd(List list, Object o) {
        list.add(o);
    }
}

由于 unsafeAdd 方法没有使用泛型，导致可以向 List<String> 中添加 Integer，编译时不会报错，但运行时会抛出 ClassCastException。

c. 不能创建泛型数组

由于类型擦除，Java 不允许直接创建泛型类型的数组：

// List<String>[] listArray = new List<String>[10]; // 编译错误
List<String>[] listArray = (List<String>[]) new List[10];  // 通过强制类型转换实现

这主要是因为数组在运行时会执行类型检查，而泛型类型擦除后会导致数组元素类型信息丢失。

d. 不能实例化泛型类型

由于泛型类型在运行时被擦除为 Object 或它的上界类型，Java 不允许直接实例化泛型类型：

public class Box<T> {
    // T value = new T(); // 编译错误
    T value;
    
    public Box(Class<T> clazz) {
        try {
            value = clazz.getDeclaredConstructor().newInstance(); // 使用反射实例化
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

为了实例化泛型对象，通常使用反射并传入 Class<T> 对象。

e. 泛型方法的重载问题

泛型方法在编译后会被擦除，因此不能依赖泛型类型来区分重载方法：

public class Example {
    public void method(List<String> list) {}
    public void method(List<Integer> list) {}  // 编译错误，方法重复
}

编译器会认为这两个方法是相同的，因为泛型信息会被擦除。

3. 如何应对泛型擦除的影响

• 使用类型标记（Type Token）：通过传递 Class<T> 来保留类型信息，如前面例子中提到的反射实例化。
• 使用 instanceof 和 getClass：小心使用 instanceof 和 getClass()，避免类型信息丢失。
• 谨慎处理泛型数组：如果必须使用泛型数组，可以通过类型转换来实现，但需注意类型安全性。

泛型擦除是 Java 保持向后兼容性的重要机制，但它也带来了一些运行时的限制和潜在的类型安全问题。在使用泛型时，理解泛型擦除及其影响，有助于编写更健壮的代码。