一句话，讲清楚java泛型的本质（非类型擦除）

背景

昨天，在逛论坛时遇到个这么个问题，上代码：

public class GenericTest {
    //方法一
    public static <T extends Comparable<T>> List<T> sort(List<T> list) {
        return Arrays.asList(list.toArray((T[]) new Comparable[list.size()]));
    }

    //方法二
    public static <T extends Comparable<T>> T[] sort2(List<T> list) {
        // 这里没报错
        return list.toArray((T[]) new Comparable[list.size()]);
    }

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        // 方法一调用正常
        System.out.println(sort(list).getClass());
        // 方法二调用报错了，这里报错了
        System.out.println(sort2(list).getClass());
    }
}

这个问题有如下四个现象：

（1）方法一调用彻底正常；

（2）方法二调用报错了；

（3）方法二报错的地方是在System.out.println(sort2(list).getClass());这行，而不是return list.toArray((T[]) new Comparable[list.size()]);这行；

（4）报的错是[Ljava.lang.Comparable; cannot be cast to [Ljava.lang.Integer;；

怎么样？你心中有答案嘛？类型擦除？怎么擦？摩擦摩擦？

解决

刚拿到这道题，我也是一脸懵逼，这要报错也应该是在return list.toArray((T[]) new Comparable[list.size()]);这行啊，并且要报错应该两个方法都报错啊。

抱着不放弃不抛弃的心态，彤哥作了大量的实验，终于得出了泛型的本质，且听我娓娓道来。

小插曲

首先，咱们要明白，java中的数组是不支持向下转型的，可是若是自己就是那个类型的是能够转过去的，请看下面的例子：

public static void main(String[] args) {
    Object[] objs = new Object[]{1};
    // 类型转换错误
//  Integer[] ins = (Integer[]) objs;

    Object[] objs2 = new Integer[]{1};
    // 不报错
    Integer[] ins2 = (Integer[]) objs2;

}

类型擦除

java里的泛型是假泛型，只在编译期有效，在运行时是没有泛型的概念的，举个简单的例子：

public static void main(String[] args) {
        List<String> strList = Arrays.asList("1");
        List<Integer> intList = Arrays.asList(1);

        // 打印：true
        System.out.println(strList.getClass() == intList.getClass());
    }

能够看到两个list的类型是同样的，若是你以为这个例子不够说服力，那我给你个过度点的例子：

public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
    List<String> strList = new ArrayList<>();

    Method addMethod = strList.getClass().getMethod("add", Object.class);
    addMethod.invoke(strList, 1);
    addMethod.invoke(strList, true);
    addMethod.invoke(strList, new Long(1));
    addMethod.invoke(strList, new Byte[]{1});

    // 打印：[1, true, 1, 1]
    System.out.println(strList);
}

瞧，我能够往一个String类型的List中扔任何我想扔的东西，服不服？！

因此说java里面的泛型是假的，运行时不存在滴。

回归正题

数组不能向下强转我懂了，类型擦除我也懂了，彷佛仍是过很差这一辈子，呃不是，是仍是解决不了这道题啊？

呃，好像是~~

咱们再来看一个简单的例子：

// GenericTest2.java（源码）
public class GenericTest2 {
    public static void main(String[] args) {
        System.out.println(raw("1"));
    }

    public static <T> T raw(T t) {
        return t;
    }
}
// GenericTest2.class（反编译）
public class GenericTest2 {
    public GenericTest2() {
    }

    public static void main(String[] args) {
        System.out.println((String)raw("1"));
    }

    public static <T> T raw(T t) {
        return t;
    }
}

嗯~彷佛看出来点端倪，反编译后多了个构造方法。

呃，没错。还有呢？

仔细一看，System.out.println((String)raw("1"));这一句多加了个String强转。

这就是关键所在，结合类型擦除，运行时并无所谓的泛型，因此raw()返回的实际上是Object，可是调用者本身知道我要的是String类型啊，因此我就知道强转一下喽。

咱们再来看个极端的例子：

// GenericTest2.java（源码）
public class GenericTest2 {
    public static void main(String[] args) {
        System.out.println(raw("1"));
    }

    public static <T> T raw(T t) {
        return (T)new Integer(1);
    }
}
// GenericTest2.class（反编译）
public class GenericTest2 {
    public GenericTest2() {
    }

    public static void main(String[] args) {
        System.out.println((String)raw("1"));
    }

    public static <T> T raw(T t) {
        return new Integer(1);
    }
}

仔细观察，能够发现，raw()方法里的强转(T)new Integer(1)变成了new Integer(1)，强转被擦除了，实际上在运行时这里的T变成了Object，全部类型都是Object的子类，也就不须要强转了。

而(String)raw("1")的强转仍是加上的，这是调用者知道类型是String，因此raw()返回后本身强转成String一下。

固然，这个代码运行是会报错的，java.lang.Integer cannot be cast to java.lang.String，由于raw()返回的是Integer类型，强转成String类型失败了。

好了，基本思路就是这样。

泛型类呢？

咱们上面举的例子都是泛型方法，那么泛型类呢？

一样地，咱们来看个例子：

// GenericTest3.java（源码）
public class GenericTest3 {
    public static void main(String[] args) {
        System.out.println(new Raw<String>().raw("1"));
    }
}
class Raw<T> {
    public T raw(T t) {
        return (T)new Integer(1);
    }
}
// GenericTest3.class（反编译）
public class GenericTest3 {
    public GenericTest3() {
    }

    public static void main(String[] args) {
        System.out.println((String)(new Raw()).raw("1"));
    }
}
class Raw<T> {
    Raw() {
    }

    public T raw(T t) {
        return new Integer(1);
    }
}

能够看到，跟泛型方法的表现如出一辙。固然，这里运行时也会报java.lang.Integer cannot be cast to java.lang.String这个错误。

总结

java中的泛型只在编译期有效，在运行时只有调用者知道须要什么类型，且调用者调用泛型方法后本身作强制转换，被调用者是彻底无感的。

因此，出现问题不要问被调用者，而是要问调用者，你丫是怎么调用的？！

解答开篇

为了方便咱们仍是把开篇的问题拿过来。

// GenericTest.java（源码）
public class GenericTest {
    //方法一
    public static <T extends Comparable<T>> List<T> sort(List<T> list) {
        return Arrays.asList(list.toArray((T[]) new Comparable[list.size()]));
    }

    //方法二
    public static <T extends Comparable<T>> T[] sort2(List<T> list) {
        // 这里没报错
        return list.toArray((T[]) new Comparable[list.size()]);
    }

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        // 方法一调用正常
        System.out.println(sort(list).getClass());
        // 方法二调用报错了，这里报错了
        System.out.println(sort2(list).getClass());
    }
}

这里彷佛又不太同样，变成了<T extends Comparable<T>>，实际上是同样的啦，若是单独写<T>是至关于<T extends Object>的。

那么，咱们就延伸一下，被调用者是彻底无感的，它只能尽力拿到它知道的类型，好比这里就只能尽力拿到Comparable，若是是<T>拿到的就是Object。

因此，方法二返回的就是实打实的Comparable[]类型，做为被调用者，它一点问题都没有。

可是，调用方是知道我须要的是Integer[]类型的，由于list里面是Integer类型，因此返回的应该是Integer[]类型，因此我就强转喽，而后就报错了。

究竟是不是这样？咱们来看看反编译后的代码：

// GenericTest.class（反编译）
public class GenericTest {
    public GenericTest() {
    }

    public static <T extends Comparable<T>> List<T> sort(List<T> list) {
        return Arrays.asList(list.toArray((Comparable[])(new Comparable[list.size()])));
    }

    public static <T extends Comparable<T>> T[] sort2(List<T> list) {
        // 这里使用的是Comparable[]强转，因此返回的也是实打实的Comparable[]类型
        return (Comparable[])list.toArray((Comparable[])(new Comparable[list.size()]));
    }

    public static void main(String[] args) {
        List<Integer> list = new ArrayList();
        list.add(1);
        list.add(2);
        System.out.println(sort(list).getClass());
        // 数组向下转型失败
        System.out.println(((Integer[])sort2(list)).getClass());
    }
}

能够看到，跟咱们的分析彻底一致。

一句话，一生

java中的泛型只在编译期有效，在运行时只有调用者知道它本身须要什么类型，且调用者调用泛型方法后本身作强制转换，被调用者是彻底无感的，被调用者只能尽力拿到它所知道的类型。

此时，个人脑海中不经响起那熟悉的旋律，“一句话，一生……”，今天的这句话你记住了吗？

---