泛型擦除与泛型数组

泛型信息只存在于代码编译阶段，在进入 JVM 之前，与泛型相关的信息会被擦除掉，专业术语叫做类型擦除

通俗地讲，泛型类和普通类在 java 虚拟机内是没有什么特别的地方。回顾文章开始时的那段代码

List<String> l1 = new ArrayList<String>();

List<Integer> l2 = new ArrayList<Integer>();

System.out.println(l1.getClass() == l2.getClass());

打印的结果为 true 是因为 List<String> 和 List<Integer> 在 jvm 中的 Class 都是 List.class。泛型信息被擦除了。

可能同学会问，那么类型 String 和 Integer 怎么办？

答案是泛型转译。

public class Erasure <T>{

    T object;

    public Erasure(T object) {

        this.object = object; }

}

Erasure 是一个泛型类，我们查看它在运行时的状态信息可以通过反射。

Erasure<String> erasure = new Erasure<String>("hello");

Class eclz = erasure.getClass();

System.out.println("erasure class is:"+eclz.getName());

打印的结果是

erasure class is:com.frank.test.Erasure

Class 的类型仍然是 Erasure 并不是 Erasure<T> 这种形式，那我们再看看泛型类中 T 的类型在 jvm 中是什么具体类型。

Field[] fs = eclz.getDeclaredFields();

for ( Field f:fs) {

    System.out.println("Field name "+f.getName()+" type:"+f.getType().getName());

}

打印结果是

Field name object type:java.lang.Object

那我们可不可以说，泛型类被类型擦除后，相应的类型就被替换成 Object 类型呢？

这种说法，不完全正确。

我们更改一下代码。

public class Erasure <T extends String>{

// public class Erasure <T>

T object;

    public Erasure(T object) {

        this.object = object;

    }

}

现在再看测试结果：

Field name object type:java.lang.String

我们现在可以下结论了，在泛型类被类型擦除的时候，之前泛型类中的类型参数部分如果没有指定上限，如 <T> 则会被转译成普通的 Object 类型，如果指定了上限如 <T extends String> 则类型参数就被替换成类型上限。

类型擦除带来的局限性

类型擦除，是泛型能够与之前的 java 版本代码兼容共存的原因。但也因为类型擦除，它会抹掉很多继承相关的特性，这是它带来的局限性。

理解类型擦除有利于我们绕过开发当中可能遇到的雷区，同样理解类型擦除也能让我们绕过泛型本身的一些限制。比如 

正常情况下，因为泛型的限制，编译器不让最后一行代码编译通过，因为类似不匹配，但是，基于对类型擦除的了解，利用反射，我们可以绕过这个限制。

public interface List<E> extends Collection<E>{

    boolean add(E e);

}

上面是 List 和其中的 add() 方法的源码定义。

因为 E 代表任意的类型，所以类型擦除时，add 方法其实等同于

boolean add(Object obj);

那么，利用反射，我们绕过编译器去调用 add 方法。

public class ToolTest {

    public static void main(String[] args) {

         List<Integer> ls = new ArrayList<>();

         ls.add(23);

    // ls.add("text");

        try {

            Method method = ls.getClass().getDeclaredMethod("add",Object.class);

            method.invoke(ls,"test");

            method.invoke(ls,42.9f); }

             catch (NoSuchMethodException e) {

                e.printStackTrace();

            } catch (SecurityException e) {

                e.printStackTrace();

            } catch (IllegalAccessException e) {

                e.printStackTrace();

            } catch (IllegalArgumentException e) {

                e.printStackTrace();

           } catch (InvocationTargetException e) {

                e.printStackTrace();

            }

     for ( Object o: ls){

    System.out.println(o);

           }

        }

}

打印结果是：

23

test

42.9

可以看到，利用类型擦除的原理，用反射的手段就绕过了正常开发中编译器不允许的操作限制。

Java 不能创建具体类型的泛型数组

首先需要对数组有进一步了解

在Java中，Object[]数组可以是任何数组的父类，也就是说，任何一个数组都可以向上转型成它在定义时指定元素类型的父类的数组，在转型后，如果我们往里面放不同于原始数据类型 但是满足后来使用的父类类型的话，编译不会有问题，但是在运行时会检查加入数组的对象的类型，于是会抛ArrayStoreException：

String[]strArray=newString[20];

Object[]objArray=strArray;

objArray[0]=newInteger(1); // throws ArrayStoreException at runtime

// 假设可以创建泛型数组

List<String>[] stringLists = new ArrayList<String>[1];

// 泛型擦除的原因，List<String>视为List，其数组可直接转型Obejct[]

Object[] objects = stringLists;

List<Integer> intList = Arrays.asList(42);

//同理，List<Integer>视为List， 可以直接赋值给 Object 类型变量

objects[0] = intList;

// 但此时出现问题了，List<Integer> 实例添加到了声明为 List<String>[] 类型的数组中

String s = stringLists[0].get(0);

通过这种方式，可以避开编译时期的错误，但在运行时期则会抛出ArrayStoreException

所以，JAVA规定不允许这种形式的泛型数组。

另类实现泛型数组

待改进代码

public class GenericArray2<T> {
    private Object[] array;  //维护Object[]类型数组
    @SupperessWarning("unchecked")
    public GenericArray2(int sz) {
        array = new Object[sz];
    }
    public void put(int index, T item) {
        array[index] = item;
    }
    public T get(int index) { return (T)array[index]; }//数组对象出口强转
    // 强转只影响编译期，运行时无论怎样都是Object[]类型 
    public T[] rep() { return (T[])array; } 

    public static void main (String[] args){
        GenericArray<Integer> gai = new GenericArray<Integer>(10);
        // Integer[] ia = gai.rep(); //依旧ClassCastException
        Object[] oa = gai.rep(); //只能返回对象数组类型为Object[]
        gai.put(0,11);
        System.out.println(gai.get(0)); // 11 ,出口成功转型
    }
}

最终方案

import java.lang.reflect.*; 

public class GenericArrayWithTypeToken<T> {
    private T[] array;
    @SuppressWarning("unchecked")
    public GenericArrayWithTypeToken(Class<T> type, int sz) {
        array = (T[]) Array.newInstance(type, sz);//通过反射在运行时构出实际类型为type[]的对象数组，避免了类型擦除，从而转换成功，无ClassCastException
    }
    public void put(int index, T item){
        array[index] = item;
    }
    public T get(int index) { return array[index]; }
    public T[] rep() { return array; }  //能成功返回了~
    public static void main(String[] args) {
        GenericArrayWithTypeToken<Integer> gawtt = new GenericArrayWithTypeToken<>(Integer.class, 10);
        Integer[] ia = gawtt.rep(); //能成功返回了！
    }
}