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 
    }
}