`

Java泛型-类型擦除

    博客分类:
  • Java
阅读更多

 

一、概述

      Java泛型在使用过程有诸多的问题,如不存在List<String>.class, List<Integer>不能赋值给List<Number>(不可协变),奇怪的ClassCastException等。 正确的使用Java泛型需要深入的了解Java的一些概念,如协变,桥接方法,以及这篇笔记记录的类型擦除。Java泛型的处理几乎都在编译器中进行,编译器生成的bytecode是不包涵泛型信息的,泛型类型信息将在编译处理是被擦除,这个过程即类型擦除。

二、编译器如何处理泛型?

     通常情况下,一个编译器处理泛型有两种方式:
     1.Code specialization
。在实例化一个泛型类或泛型方法时都产生一份新的目标代码(字节码or二进制代码)。例如,针对一个泛型list,可能需要 针对stringintegerfloat产生三份目标代码。
     2.Code sharing
。对每个泛型类只生成唯一的一份目标代码;该泛型类的所有实例都映射到这份目标代码上,在需要的时候执行类型检查和类型转换。
     C++
中的模板(template)是典型的Code specialization实现。C++编译器会为每一个泛型类实例生成一份执行代码。执行代码中integer liststring list是两种不同的类型。这样会导致代码膨胀(code bloat),不过有经验的C++程序员可以有技巧的避免代码膨胀。
     Code specialization
另外一个弊端是在引用类型系统中,浪费空间,因为引用类型集合中元素本质上都是一个指针。没必要为每个类型都产生一份执行代码。而这也是Java编译器中采用Code sharing方式处理泛型的主要原因。
     Java
编译器通过Code sharing方式为每个泛型类型创建唯一的字节码表示,并且将该泛型类型的实例都映射到这个唯一的字节码表示上。将多种泛型类形实例映射到唯一的字节码表示是通过类型擦除(type erasue)实现的。

三、 什么是类型擦除?

     类型擦除指的是通过类型参数合并,将泛型类型实例关联到同一份字节码上。编译器只为泛型类型生成一份字节码,并将其实例关联到这份字节码上。类型擦除的关键在于从泛型类型中清除类型参数的相关信息,并且再必要的时候添加类型检查和类型转换的方法。
     
类型擦除可以简单的理解为将泛型java代码转换为普通java代码,只不过编译器更直接点,将泛型java代码直接转换成普通java字节码。
     
类型擦除的主要过程如下:
     1.
将所有的泛型参数用其最左边界(最顶级的父类型)类型替换。
     2.
移除所有的类型参数。
     

interface Comparable <A> { 
  public int compareTo( A that); 
} 
final class NumericValue implements Comparable <NumericValue> { 
  priva te byte value;  
  public  NumericValue (byte value) { this.value = value; }  
  public  byte getValue() { return value; }  
  public  int compareTo( NumericValue t hat) { return this.value - that.value; } 
} 
-----------------
class Collections {  
  public static <A extends Comparable<A>>A max(Collection <A> xs) { 
    Iterator <A> xi = xs.iterator(); 
    A w = xi.next(); 
    while (xi.hasNext()) { 
      A x = xi.next(); 
      if (w.compareTo(x) < 0) w = x; 
    } 
    return w; 
  } 
} 
final class Test { 
  public static void main (String[ ] args) { 
    LinkedList <NumericValue> numberList = new LinkedList <NumericValue> (); 
    numberList .add(new NumericValue((byte)0));  
    numberList .add(new NumericValue((byte)1));  
    NumericValue y = Collections.max( numberList );  
  } 
}

经过类型擦除后的类型为
 
interface Comparable { 

  public int compareTo( Object that); 
} 
final class NumericValue implements Comparable { 
  priva te byte value;  
  public  NumericValue (byte value) { this.value = value; }  
  public  byte getValue() { return value; }  
  public  int compareTo( NumericValue t hat)   { return this.value - that.value; } 
  public  int compareTo(Object that) { return this.compareTo((NumericValue)that);  } 
} 
-------------
class Collections {  
  public static Comparable max(Collection xs) { 
    Iterator xi = xs.iterator(); 
    Comparable w = (Comparable) xi.next(); 
    while (xi.hasNext()) { 
      Comparable x = (Comparable) xi.next(); 
      if (w.compareTo(x) < 0) w = x; 
    } 
    return w; 
  } 
} 
final class Test { 
  public static void main (String[ ] args) { 
    LinkedList numberList = new LinkedList(); 
    numberList .add(new NumericValue((byte)0));  ,
    numberList .add(new NumericValue((byte)1));  
    NumericValue y = (NumericValue) Collections.max( numberList );  
  } 
}

第一个泛型类Comparable <A>擦除后 A被替换为最左边界ObjectComparable<NumericValue>的类型参数NumericValue被擦除掉,但是这直 接导致NumericValue没有实现接口ComparablecompareTo(Object that)方法,于是编译器充当好人,添加了一个桥接方法。
第二个示例中限定了类型参数的边界<A extends Comparable<A>>AA必须为Comparable<A>的子类,按照类型擦除的过程,先讲所有的类型参数 ti换为最左边界Comparable<A>,然后去掉参数类型A,得到最终的擦除后结果。

四、类型擦除带来的问题

     正是由于类型擦除的隐蔽存在,直接导致了众多的泛型灵异问题。
 Q1.
用同一泛型类的实例区分方法签名?——NO
    import java.util.*;

    public class Erasure{

            public void test(List<String> ls){
                System.out.println("Sting");
            }
            public void test(List<Integer> li){
                System.out.println("Integer");
            }
    }

编译该类,

 

参数类型明明不一样啊,一个List<String>,一个是List<Integer>,但是,偷偷的说,type erasure之后,它就都是List⋯⋯
Q2. 
同时catch同一个泛型异常类的多个实例?——NO
同理,如果定义了一个泛型一场类GenericException<T>,千万别同时catch GenericException<Integer>GenericException<String>,因为他们是一样一样滴⋯⋯
Q3.
泛型类的静态变量是共享的?——Yes
猜猜这段代码的输出是什么?

import java.util.*;

public class StaticTest{
    public static void main(String[] args){
        GT<Integer> gti = new GT<Integer>();
        gti.var=1;
        GT<String> gts = new GT<String>();
        gts.var=2;
        System.out.println(gti.var);
    }
}
class GT<T>{
    public static int var=0;
    public void nothing(T x){}
}

答案是——2!由于经过类型擦除,所有的泛型类实例都关联到同一份字节码上,泛型类的所有静态变量是共享的。

五、Just remember

1.虚拟机中没有泛型,只有普通类和普通方法
2.
所有泛型类的类型参数在编译时都会被擦除
3.
创建泛型对象时请指明类型,让编译器尽早的做参数检查(Effective Java,第23条:请不要在新代码中使用原生态类型)
4.
不要忽略编译器的警告信息,那意味着潜在的ClassCastException等着你。

分享到:
评论
6 楼 zslin2011 2015-02-03  
justjavac 写道
zslin2011 写道
所有泛型类的类型参数在编译时都会被擦除?和普通类没区别了,那么编译器怎么知道List是泛型类,String不是泛型类?String<String> str = new <String>String("String");

无法知道。

你未理解我的意思,编译器肯定知道List是泛型类,String不是泛型类,因为,它可以对List弹出泛型提示,所以猜测在字节码文件中还是存储了泛型信息的。而且通过Java的反射机制也可以获取到该类的泛型信息,所以“所有泛型类的类型参数在编译时都会被擦除”这句话有问题。
5 楼 justjavac 2014-09-04  
zslin2011 写道
所有泛型类的类型参数在编译时都会被擦除?和普通类没区别了,那么编译器怎么知道List是泛型类,String不是泛型类?String<String> str = new <String>String("String");

无法知道。
4 楼 zslin2011 2014-08-10  
虚拟机中没有泛型,只有普通类和普通方法?没有泛型?可以反射到泛型的信息怎么解释?
3 楼 zslin2011 2014-08-10  
所有泛型类的类型参数在编译时都会被擦除?和普通类没区别了,那么编译器怎么知道List是泛型类,String不是泛型类?String<String> str = new <String>String("String");
2 楼 zqb666kkk 2014-03-08  
写的 真好 我看了 java核心技术基础篇 泛型类型擦除这块 看的很模糊
看了你的文章后 明白了 很多
1 楼 carlzhao531 2013-10-25  
大神你为何这么吊,看了你的文章豁然开朗

相关推荐

    解析Java泛型的类型擦除.pdf

    在 Java 语言中,泛型类型擦除的机制使得开发者难以理解和使用泛型,例如,在 Java 中,我们可以定义一个泛型类 `ArrayList&lt;T&gt;`,其中 `T` 是类型参数,但是,在编译后的字节码文件中,泛型类型信息已经被擦除,所有...

    Java泛型类型擦除后的补偿

    本文将深入探讨Java泛型类型擦除的概念,并介绍在类型擦除后,为了保持泛型的安全性和便利性,Java设计者所采取的一些补偿机制。 1. **类型擦除**: - 在编译期间,所有的泛型类型信息都会被替换为它们的实际类型...

    Java 泛型擦除后的三种补救方法

    然而,Java 的泛型在运行时是被擦除的,这意味着在运行时刻,所有的泛型类型信息都会丢失,无法直接用来创建对象或进行类型检查。这导致我们无法使用 `new T()` 或 `instanceof` 这样的操作。为了解决这个问题,我们...

    Java-Edge#Java-Interview-Tutorial#Java语法糖之泛型与类型擦除1

    - 泛型擦除前的例子把这段Java代码编译成Class文件,然后再用字节码反编译后,將会发现泛型都不见了,又变回了Java泛型出现之前的写法,泛型类型都变回了原

    Java泛型擦除深度解析:原理、影响与编程实践

    然而,Java泛型的实现机制——类型擦除,也带来了一系列的问题和限制。本文将深入探讨Java泛型擦除的工作原理、它对编程的影响,以及在实际开发中的应对策略。 Java泛型的类型擦除机制是Java泛型实现的核心,它使得...

    很好的Java泛型的总结

    Java泛型机制详解 Java泛型是Java语言中的一种机制,用于在编译期检查类型安全。Java泛型的出现解决了Java早期版本中类型安全检查的缺陷。Java泛型的好处是可以在编译期检查类型安全,避免了运行时的...

    java 泛型类的类型识别示例

    综上所述,虽然Java泛型在编译后会进行类型擦除,但通过上述技巧,我们仍然能够在运行时获得关于泛型类实例化类型的一些信息。在实际开发中,这些方法可以帮助我们编写更加灵活和安全的代码。在示例文件`GenericRTTI...

    29-API-集合框架-泛型-使用_java_

    通过学习和掌握Java泛型,开发者能够编写出更健壮、类型安全的代码,减少类型转换错误,提升代码质量。这个视频教程"29-API-集合框架-泛型-使用"应该会深入浅出地讲解这些概念,对于想要提升Java编程技能的初学者或...

    java中的泛型-详细

    总的来说,Java泛型提供了一种强大的工具,让开发者能够编写更加安全、灵活且可复用的代码。它简化了类型转换,增强了类型检查,并通过类型擦除保持了与现有Java代码的兼容性。理解和熟练运用泛型是每个Java开发者的...

    Java 泛型总结(一):基本用法与类型擦除

    "Java 泛型总结(一):基本用法与类型擦除" Java 泛型是 Java 语言中的一种强大功能,它可以使代码更加简洁、安全。下面是对 Java 泛型的基本用法和类型擦除机制的介绍。 泛型的基本用法 ------------- 泛型是...

    java泛型技术之发展

    - **类型擦除**:Java泛型采用了类型擦除的策略,这意味着在编译期间,泛型信息会被删除,只留下原始的无参数类型,这解决了与Java的向下兼容问题。 - **JDK 5.0引入**:Java 5.0正式引入泛型,使得在编译时期就能...

    Java泛型与类型擦除

    这个过程由“类型擦除”实现。但是并非像许多开发者认为的那样,在 &lt;..&gt; 符号内的东西都被擦除了。看下面这段代码: public class ClassTest { public static void main(String[] args) throws Exception { ...

    关于java基础的泛型的练习

    Java泛型是Java SE 5.0引入的一个重要特性,它极大地增强了代码的类型安全性和可读性。泛型在编程中的应用广泛,特别是在集合框架中,使得我们可以在编译时就检查类型,避免了不必要的类型转换,并且提高了代码的...

    java 泛型入门 实例

    - Java泛型在编译后会进行类型擦除,这意味着运行时没有泛型类型信息。因此,泛型主要用于编译时类型检查,而不是运行时。 - 类型擦除会导致一些限制,比如不能创建泛型数组,因为数组的类型在运行时是确定的。 5...

    Java泛型_Java中的泛型结构_

    Java泛型是Java编程语言中一个强大的特性,它允许在定义类、接口和方法时使用类型参数,从而实现参数化类型。泛型的主要目标是提高代码的类型安全性和重用性,减少类型转换的麻烦,并在编译时捕获可能的类型错误。...

    Java泛型应用实例

    Java泛型是Java编程语言中的一个强大特性,它允许我们在定义类、接口和方法时指定类型参数,从而实现代码的重用和类型安全。在Java泛型应用实例中,我们可以看到泛型如何帮助我们提高代码的灵活性和效率,减少运行时...

    关于C#、java泛型的看法

    另一方面,Java的泛型类型擦除带来了一定的灵活性,使得旧的无泛型代码能够与新的泛型代码兼容,这对于维护大型遗留项目尤其有利。然而,这也意味着Java开发者需要额外注意类型转换的安全性,避免出现...

Global site tag (gtag.js) - Google Analytics