文档章节

一句话,讲清楚java泛型的本质(非类型擦除)

o
 osc_w9s1w4o0
发布于 2019/04/13 11:48
字数 1785
阅读 11
收藏 0

精选30+云产品,助力企业轻松上云!>>>

背景

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

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中的泛型只在编译期有效,在运行时只有调用者知道它自己需要什么类型,且调用者调用泛型方法后自己做强制转换,被调用者是完全无感的,被调用者只能尽力拿到它所知道的类型。

此时,我的脑海中不经响起那熟悉的旋律,“一句话,一辈子……”,今天的这句话你记住了吗?


qrcode

o
粉丝 0
博文 500
码字总数 0
作品 0
私信 提问
加载中
请先登录后再评论。
一句话,讲清楚java泛型的本质(非类型擦除)

背景 昨天,在逛论坛时遇到个这么个问题,上代码: 这个问题有以下四个现象: (1)方法一调用完全正常; (2)方法二调用报错了; (3)方法二报错的地方是在这行,而不是这行; (4)报的错...

彤哥读源码
2019/04/13
520
1
java泛型Generics

what 泛型:一般类型,也就是说可以为任何类型. 泛型的本质是“参数化类型”,也就是说: 所操作的数据类型 被指定为一个参数, 传输。泛型是在JDK1.5中引入的特性。 why 泛型提供了编译时类型...

凯歌的博客
2019/03/31
3
0
C++泛型 && Java泛型实现机制

C++泛型   C++泛型跟虚函数的运行时多态机制不同,泛型支持的静态多态,当类型信息可得的时候,利用编译期多态能够获得最大的效率和灵活性。当具体的类型信息不可得,就必须诉诸运行期多态...

osc_7lf307y4
2018/06/07
9
0
Java泛型与数组深入研究

Java中的泛型与数组平时开发用的很多,除了偶尔遇到"NullPointerException"和"IndexOutOfBoundsException"一般也不会遇到太大问题。可是如果深入研究,可能会发现这两种类型有很多奇怪的特点...

osc_jqntvyw1
02/15
1
0
java泛型的简单认识及需要注意类型擦除

泛型是Java SE 1.5的新特性,泛型的本质是参数化类型。 在1.5之前,可以使用Object实现类似泛型的功能,但泛型最大的好处就是不需要强转类型,减少了可能存在的运行时异常。 限制泛型 class ...

osc_x0g6o8z1
2018/12/27
6
0

没有更多内容

加载失败,请刷新页面

加载更多

Linux系统检查用户账户到期时间

如果你在 Linux 上启用了密码策略。密码必须在到期前进行更改,并且登录到系统时会收到通知。如果你很少使用自己的帐户,那么可能由于密码过期而被锁定。在许多情况下,这可能会在无需密码登...

老孟的Linux私房菜
45分钟前
13
0
关于南京哪里有开餐饮费发票?

关于南京哪里有开餐饮费发票?聚焦餐饮行业,谈话〖18 7一電一7 5 3 8一徴一3331〗研究院昨发布数据显示,今年上半年,全国餐饮行业招聘需求增长46.18%,平均月薪6387元.随着餐饮行业的快速...

点击fojewio
今天
7
0
android studio 4.0 打开DDMS

1、先找到AndroidStudio配置的SDK路径; 2、在SDK的/tools/路径下有个monitor.bat 的批处理文件; 3、鼠标连续点击两下monitor.bat这个批处理文件,在屏幕上会打开一个类似CMD的命令行中输入...

chenhongjiang
今天
10
0
如何在Android中使用SharedPreferences来存储,获取和编辑值

问题: Closed . 已关闭 。 This question needs to be more focused. 这个问题需要更加集中。 It is not currently accepting answers. 它当前不接受答案。 Learn more . 了解更多 。 Want...

fyin1314
今天
6
0
【JDK1.8】LinkedList源码分析

LinkedList的特性 LinkedList内部使用双向链表作为存储结构,LinkedList可以理解为链表的扩展对象,封装了常用的和非常用的操作链表的方法。以及在通过索引获取元素时的简单优化,通常Linke...

XuePeng77
今天
40
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部