Java泛型(5)：擦除与补偿

先看一个例子：

Class<?> c1 = new ArrayList<String>().getClass();
Class<?> c2 = new ArrayList<Integer>().getClass();
System.out.println(c1 == c2); // true

虽然泛型类的参数不同，但是结果却是TRUE。这是因为在泛型代码内部，无法获得任何有关泛型参数类型的信息。

Java泛型是通过擦除来实现的。这意味着当你在使用泛型时，任何具体的类型信息都被擦除了，你唯一知道的是你在使用一个对象。因此List<String>和List<Integer>在运行时事实上都被擦除成原生的List类型。

运行时，使用泛型和使用Object所产生的字节码是相同的。因此，泛型是在编译期对代码进行检查的。

擦除丢失了在泛型代码中执行某些操作的能力。尽管你一厢情愿想地想把泛型参数替换成为你想要的类型，但是实际上它什么都不是。任何在运行时需要知道确切类型信息的操作都将无法工作。

T t = new T(); // Compile error
T[] t = new T[](); // Compile error
if(c1 instanceof T) {} // Compile error

可以通过引用类型参数来对擦除进行补偿。即显式地传递该类型的class对象。下面介绍了3种方法：

(1) 直接传递一个Class<T>的内建工厂对象。缺点是如果T实例化(newInstance();)失败，编译期不能捕获异常。

 class ClassAsFactory<T> {
     T x;
     public ClassAsFactory(Class<T> kind) {
         try {
             x = kind.newInstance();
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }
 }

 class Employee { }

 public class InstantiateGenericType {
     public static void main(String[] args) {
         new ClassAsFactory<Employee>(Employee.class);
         System.out.println("ClassAsFactory<Employee> succeeded");
         try {
             // Integer并没有默认构造器，所以调用newInstance()时会报Error
             new ClassAsFactory<Integer>(Integer.class);
         } catch (Exception e) {
             System.out.println("ClassAsFactory<Integer> failed");
         }
     }
 }

(2) 创建一个显式的工厂对象。它可以很好的限制对象类型。

 interface FactoryI<T> {
     T create();
 }

 class Foo<T> {
     public final T x;

     public <F extends FactoryI<T>> Foo(F factory) {
         x = factory.create();
     }
 }

 // 直接实现FactoryI接口
 class IntegerFactory implements FactoryI<Integer> {
     @Override
     public Integer create() {
         return new Integer(0);
     }
 }

 // 创建静态内部类实现FactoryI接口
 class Widget {
     public static class Factory implements FactoryI<Widget> {
         @Override
         public Widget create() {
             return new Widget();
         }
     }
 }

 public class FactoryConstraint {
     public static void main(String[] args) {
         new Foo<Integer>(new IntegerFactory());
         new Foo<Widget>(new Widget.Factory());
     }
 }

(3) 使用模版方法设计模式创建抽象类，由具体的子类实现创建对象。

 abstract class GenericWithCreate<T> {
     final T element;
     GenericWithCreate() {
         element = create();
     }
     abstract T create();
 }

 class Clazz { }

 class Creator extends GenericWithCreate<Clazz> {

     Creator() {
         System.out.println(element.getClass().getSimpleName());
     }

     Clazz create() {
         Clazz clazz = new Clazz();
         return clazz;
     }
 }

 public class CreatorGeneric {
     public static void main(String[] args) {
         new Creator(); // Clazz
     }
 }

对于创建泛型数组的情况，一般来说使用ArrayList代替。成功创建泛型数组的唯一方法就是创建一个被擦除类型的新数组(T[] array = (T[]) new Object[size];)，并且这个数组的类型只能是Object[]。下面介绍了2种方法：

(1) 使用new Object[size]。缺点是由于擦除，我们无法判定创建好的数组的具体类型。例子中如果改成Integer，则会抛出ClassCastException。

 public class GenericArray<T> {
     private T[] array;

     @SuppressWarnings("unchecked")
     public GenericArray(int size) {
         array = (T[]) new Object[size];
     }

     public void put(int index, T item) {
         array[index] = item;
     }

     public T get(int index) {
         return (T) array[index];
     }

     public T[] rep() {
         return (T[]) array;
     }

     public static void main(String[] args) {
         GenericArray<Integer> gai = new GenericArray<Integer>(10);
         for (int i = 0; i < 10; i++)
             gai.put(i, i);
         // Integer[] ia = gai.rep(); // [ERROR] java.lang.ClassCastException
         Object[] ia = gai.rep();
         for (int i = 0; i < ia.length; i++)
             System.out.print(ia[i] + " "); // 0 1 2 3 4 5 6 7 8 9
     }
 }

(2) 使用Array.newInstance(type, size)。这时需要传入一个类型标记，就可以解决(1)中的问题。

 import java.lang.reflect.Array;

 public class GenericArrayWithTypeToken<T> {
     private T[] array;

     @SuppressWarnings("unchecked")
     public GenericArrayWithTypeToken(Class<T> type, int size) {
         array = (T[]) Array.newInstance(type, size);
     }

     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> gai = new GenericArrayWithTypeToken<Integer>(Integer.class, 10);
         for (int i = 0; i < 10; i++)
             gai.put(i, i);
         Integer[] ia = gai.rep(); // It's OK
         for (int i = 0; i < ia.length; i++)
             System.out.print(ia[i] + " "); // 0 1 2 3 4 5 6 7 8 9
     }
 }