[改善Java代码]数组的真实类型必须是泛型类型的子类型

List接口的toArray方法可以把一个结合转化为数组,但是使用不方便,toArray()方法返回的是一个Object数组,所以需要自行转变.

toArray(T[] a)虽然返回的是T类型的数组,但是还是需要传入一个T类型的数组,这也挺麻烦的.我们期望输入的是一个泛型化的list,这样就能转化为泛型数组了.

看代码:

import java.util.Arrays;
import java.util.List;

public class Client<T> {
    public static <T> T[] toArray(List<T> list){
        T[] t = (T[])new Object[list.size()];
        for(int i=0,n=list.size();i<n;i++){
            t[i] = list.get(i);
        }
        return t;
    }
    
    public static void main(String[] args) {
        List<String> list = Arrays.asList("A","B");
        for(String str:toArray(list)){//这一句报错
            System.out.println(str);
        }
    }
}

编译没有任何问题,运行后出现如下异常;

Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;
    at cn.summerchill.test.Client.main(Client.java:17)

类型转换异常,也就是说,不能把一个Object数组转换为String数组,这段异常包含了两个问题:

1.为什么Object数组不能向下转型为String数组?

数组是一个容器,只有确保容器内的所有元素类型与期望的类型有父子关系时才能转换,Object数组只能保证数组内的元素是Object类型.却不能确保它们都是String的父类型或子类,所以转换失败.

2.为什么是main方法抛出异常,而不是toArray方法?

其实,是在toArray方法中进行的类型向下转换,而不是main方法中,那为什么异常会在main方法中抛出,应该在toArrya方法的   T[] t = (T[])new Object[list.size()] 这段才对啊....

那是因为泛型是类型擦除的,toArray方法经过编译后与如下代码相同:

import java.util.Arrays;
import java.util.List;

public class Client<T> {
    public static Object[] toArray(List list){
        //此处的强制类型没必要存在，只是为了保持与源代码对比
        Object[] t = (Object[])new Object[list.size()];
        for(int i=0,n=list.size();i<n;i++){
            t[i] = list.get(i);
        }
        return t;
    }
    
    public static void main(String[] args) {
        List<String> list = Arrays.asList("A","B");
        for(String str:(String[])toArray(list)){
            System.out.println(str);
        }
    }
}

阅读完此段代码就很清楚了,toArray方法返回后会进行一次类型转换,Object数组转换成了String数组,于是就报了ClassCastException异常了.

Object数组不能转换成String数组,T类型又无法在运行期获得,那该如何解决这个问题呢?

其实要想把一个Object数组转换成为String数组,只要Object数组的实际类型也是String就可以了.

public class Client<T> {
    public static void main(String[] args) {
        //objArray的实际类型和表面类型都是String数组
        Object[] objArray = {"A","B"};
        //抛出ClassCastException
        String[] strArray = (String[])objArray;        
    
        String[] ss = {"A","B"};
        //objs的真实类型是String数组，显示类型为Object数组
        Object[] objs = ss;
        //顺利转换为String数组
        String[] strs = (String[])objs;        
    }
}

知道了上面,把泛型数组声明为泛型类的子类型

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.List;

public class Client<T> {

    public static <T> T[] toArray(List<T> list, Class<T> tClass) {
        //声明并初始化一个T类型的数组
        T[] t = (T[]) Array.newInstance(tClass, list.size());        
        for(int i=0,n=list.size();i<n;i++){
            t[i] = list.get(i);
        }
        return t;
    }
    public static void main(String[] args) {
        List<String> list = Arrays.asList("A", "B");
        for (String str : toArray(list,String.class)) {
            System.out.println(str);
        }
    }
}

通过反射类Array声明了一个T类型的数组,由于我们无法在运行期获得泛型类型的参数,因此就需要调用者主动传入T参数类型.此时,客户端再调用就不会出现任何异常了.

在这里我们看到,一个泛型类(特别是泛型集合)转变为泛型数组时,泛型数组的真实类型不能是泛型类型的父类型(比如顶层类Object),只能是泛型类型的子类型(当然包含自身类型),否则就会出现类型转换异常.