[置顶] JAVA泛型机制

基本理论转自：：http://blog.csdn.net/sunxianghuang/article/details/51982979

泛型数组的实现转自：：http://blog.csdn.net/yi_Afly/article/details/52058708
请原谅我把大佬们的博客copy到一起，如有版权问题，发邮件到2735613123@qq.com

泛型之前

在面向对象编程语言中，多态算是一种泛化机制。例如，你可以将方法的参数类型设置为基类，那么该方法就可以接受从这个基类中导出的任何类作为参数，这样的方法将会更具有通用性。此外，如果将方法参数声明为接口，将会更加灵活。

在Java增加泛型类型之前，通用程序的设计就是利用继承实现的，例如，ArrayList类只维护一个Object引用的数组，Object为所有类基类。

[java]  view plain  copy

1. public class BeforeGeneric {  
2.     static class ArrayList{//泛型之前的通用程序设计  
3.         private Object[] elements=new Object[0];  
4.         public Object get(int i){  
5.             return elements[i];  
6.         }  
7.         public void add(Object o){  
8.             //这里的实现，只是为了演示，不具有任何参考价值  
9.             int length=elements.length;  
10.             Object[] newElments=new Object[length+1];  
11.             for(int i=0;i<length;i++){  
12.                 newElments[i]=elements[i];  
13.             }  
14.             newElments[length]=o;  
15.             elements=newElments;  
16.         }  
17.     }  
18.     public static void main(String[] args) {  
19.         ArrayList stringValues=new ArrayList();  
20.         stringValues.add(1);//可以向数组中添加任何类型的对象  
21.         //问题1——获取值时必须强制转换     
22.         String str=(String) stringValues.get(0);   
23.         //问题2——上述强制转型编译时不会出错，而运行时报异常java.lang.ClassCastException  
24.     }  
25. }  

这样的实现面临两个问题：

1、当我们获取一个值的时候，必须进行强制类型转换。

2、假定我们预想的是利用stringValues来存放String集合，因为ArrayList只是维护一个Object引用的数组，我们无法阻止将Integer类型（Object子类）的数据加入stringValues。然而，当我们使用数据的时候，需要将获取的Object对象转换为我们期望的类型（String），如果向集合中添加了非预期的类型（如Integer），编译时我们不会收到任何的错误提示。但当我们运行程序时却会报异常：

Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
at generic.BeforeGeneric.main(BeforeGeneric.java:24)

这显然不是我们所期望的，如果程序有潜在的错误，我们更期望在编译时被告知错误，而不是在运行时报异常。

泛型

针对利用继承来实现通用程序设计所产生的问题，泛型提供了更好的解决方案：类型参数。例如，ArrayList类用一个类型参数来指出元素的类型。

[java]  view plain  copy

1. ArrayList<String> stringValues=new ArrayList<String>();  

这样的代码具有更好的可读性，我们一看就知道该集合用来保存String类型的对象，而不是仅仅依赖变量名称来暗示我们期望的类型。

[java]  view plain  copy

1. public class GenericType {  
2.     public static void main(String[] args) {    
3.         ArrayList<String> stringValues=new ArrayList<String>();  
4.         stringValues.add("str");  
5.         stringValues.add(1); //编译错误  
6.     }   
7. }  

现在，如果我们向ArrayList<String>添加Integer类型的对象，将会出现编译错误。

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
The method add(int, String) in the type ArrayList<String> is not applicable for the arguments (int)
at generic.GenericType.main(GenericType.java:8)

编译器会自动帮我们检查，避免向集合中插入错误类型的对象，从而使得程序具有更好的安全性。

总之，泛型通过类型参数使得我们的程序具有更好的可读性和安全性。

Java泛型的实现原理

擦除

[java]  view plain  copy

1. public class GenericType {  
2.     public static void main(String[] args) {    
3.         ArrayList<String> arrayString=new ArrayList<String>();     
4.         ArrayList<Integer> arrayInteger=new ArrayList<Integer>();     
5.         System.out.println(arrayString.getClass()==arrayInteger.getClass());    
6.     }    
7. }  

输出：

true

在这个例子中，我们定义了两个ArrayList数组，不过一个是ArrayList<String>泛型类型，只能存储字符串。一个是ArrayList<Integer>泛型类型，只能存储整型。最后，我们通过arrayString对象和arrayInteger对象的getClass方法获取它们的类信息并比较，发现结果为true。

这是为什么呢，明明我们定义了两种不同的类型？因为，在编译期间，所有的泛型信息都会被擦除，List<Integer>和List<String>类型，在编译后都会变成List类型（原始类型）。Java中的泛型基本上都是在编译器这个层次来实现的，这也是Java的泛型被称为“伪泛型”的原因。

原始类型

原始类型就是泛型类型擦除了泛型信息后，在字节码中真正的类型。无论何时定义一个泛型类型，相应的原始类型都会被自动提供。原始类型的名字就是删去类型参数后的泛型类型的类名。擦除类型变量，并替换为限定类型（T为无限定的类型变量，用Object替换）。

[java]  view plain  copy

1. //泛型类型  
2. class Pair<T> {    
3.     private T value;    
4.     public T getValue() {    
5.         return value;    
6.     }    
7.     public void setValue(T  value) {    
8.         this.value = value;    
9.     }    
10. }  

[java]  view plain  copy

1. //原始类型  
2. class Pair {    
3.     private Object value;    
4.     public Object getValue() {    
5.         return value;    
6.     }    
7.     public void setValue(Object  value) {    
8.         this.value = value;    
9.     }    
10. }    

因为在Pair<T>中，T是一个无限定的类型变量，所以用Object替换。如果是Pair<T extends Number>，擦除后，类型变量用Number类型替换。

[java]  view plain  copy

1. public class ReflectInGeneric {  
2.     public static void main(String[] args) throws IllegalArgumentException,   
3.                         SecurityException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {    
4.         ArrayList<Integer> array=new ArrayList<Integer>();    
5.         array.add(1);//这样调用add方法只能存储整形，因为泛型类型的实例为Integer    
6.         array.getClass().getMethod("add", Object.class).invoke(array, "asd");    
7.         for (int i=0;i<array.size();i++) {    
8.             System.out.println(array.get(i));    
9.         }    
10.     }    
11. }  

输出：

1
asd

为什么呢？我们在介绍泛型时指出向ArrayList<Integer>中插入String类型的对象，编译时会报错。现在为什么又可以了呢？

我们在程序中定义了一个ArrayList<Integer>泛型类型，如果直接调用add方法，那么只能存储整形的数据。不过当我们利用反射调用add方法的时候，却可以存储字符串。这说明ArrayList<Integer>泛型信息在编译之后被擦除了，只保留了原始类型，类型变量（T）被替换为Object，在运行时，我们可以行其中插入任意类型的对象。

但是，并不推荐以这种方式操作泛型类型，因为这违背了泛型的初衷（减少强制类型转换以及确保类型安全）。当我们从集合中获取元素时，默认会将对象强制转换成泛型参数指定的类型（这里是Integer），如果放入了非法的对象这个强制转换过程就会出现异常。

泛型方法的类型推断
在调用泛型方法的时候，可以指定泛型类型，也可以不指定。

在不指定泛型类型的情况下，泛型类型为该方法中的几种参数类型的共同父类的最小级，直到Object。

在指定泛型类型的时候，该方法中的所有参数类型必须是该泛型类型或者其子类。

[java]  view plain  copy

1. public class Test {   
2.     public static void main(String[] args) {    
3.         /**不指定泛型的时候*/    
4.         int i=Test.add(1, 2); //这两个参数都是Integer，所以T替换为Integer类型    
5.         Number f=Test.add(1, 1.2);//这两个参数一个是Integer，另一个是Float，所以取同一父类的最小级，为Number    
6.         Object o=Test.add(1, "asd");//这两个参数一个是Integer，另一个是String，所以取同一父类的最小级，为Object  
7.     
8.         /**指定泛型的时候*/    
9.         int a=Test.<Integer>add(1, 2);//指定了Integer，所以只能为Integer类型或者其子类    
10.         int b=Test.<Integer>add(1, 2.2);//编译错误，指定了Integer，不能为Float    
11.         Number c=Test.<Number>add(1, 2.2); //指定为Number，所以可以为Integer和Float    
12.     }    
13.         
14.     //这是一个简单的泛型方法    
15.     public static <T> T add(T x,T y){    
16.         return y;    
17.     }   
18. }  

正确的运转

既然说类型变量会在编译的时候擦除掉，那为什么定义了ArrayList<Integer>泛型类型，而不允许向其中插入String对象呢？不是说泛型变量Integer会在编译时候擦除变为原始类型Object吗，为什么不能存放别的类型呢？既然类型擦除了，如何保证我们只能使用泛型变量限定的类型呢？
java是如何解决这个问题的呢？java编译器是通过先检查代码中泛型的类型，然后再进行类型擦除，再进行编译的。以如下代码为例：

[java]  view plain  copy

1. Pair<Integer> pair=new Pair<Integer> ();  
2. pair.setValue(3);  
3. Integer integer=pair.getValue();  
4. System.out.println(integer);  

擦除 getValue()的返回类型后将返回Object类型，编译器自动插入Integer的强制类型转换。也就是说，编译器把这个方法调用翻译为两条字节码指令：

1、对原始方法Pair.getValue的调用

2、将返回的Object类型强制转换为Integer

此外，存取一个泛型域时，也要插入强制类型转换。因此，我们说Java的泛型是在编译器层次进行实现的，被称为“伪泛型”，相对于C++。

泛型相关问题

1、泛型类型引用传递问题

在Java中，像下面形式的引用传递是不允许的：

[java]  view plain  copy

1. ArrayList<String> arrayList1=new ArrayList<Object>();//编译错误    
2. ArrayList<Object> arrayList1=new ArrayList<String>();//编译错误   

我们先看第一种情况，将第一种情况拓展成下面的形式：

[java]  view plain  copy

1. ArrayList<Object> arrayList1=new ArrayList<Object>();    
2.           arrayList1.add(new Object());    
3.           arrayList1.add(new Object());    
4.           ArrayList<String> arrayList2=arrayList1;//编译错误    

实际上，在第4行代码处，就会有编译错误。那么，我们先假设它编译没错。那么当我们使用arrayList2引用用get()方法取值的时候，返回的都是String类型的对象，可是它里面实际上已经被我们存放了Object类型的对象，这样，就会有ClassCastException了。所以为了避免这种极易出现的错误，Java不允许进行这样的引用传递。（这也是泛型出现的原因，就是为了解决类型转换的问题，我们不能违背它的初衷）。
在看第二种情况，将第二种情况拓展成下面的形式：

[java]  view plain  copy

1. ArrayList<String> arrayList1=new ArrayList<String>();    
2.           arrayList1.add(new String());    
3.           arrayList1.add(new String());    
4.           ArrayList<Object> arrayList2=arrayList1;//编译错误    

没错，这样的情况比第一种情况好的多，最起码，在我们用arrayList2取值的时候不会出现ClassCastException，因为是从String转换为Object。可是，这样做有什么意义呢，泛型出现的原因，就是为了解决类型转换的问题。我们使用了泛型，到头来，还是要自己强转，违背了泛型设计的初衷。所以java不允许这么干。再说，你如果又用arrayList2往里面add()新的对象，那么到时候取得时候，我怎么知道我取出来的到底是String类型的，还是Object类型的呢？
所以，要格外注意泛型中引用传递问题。

2、泛型类型变量不能是基本数据类型
就比如，没有ArrayList<double>，只有ArrayList<Double>。因为当类型擦除后，ArrayList的原始类中的类型变量（T）替换为Object，但Object类型不能存储double值。
3、运行时类型查询
举个例子:

[java]  view plain  copy

1. ArrayList<String> arrayList=new ArrayList<String>();      

因为类型擦除之后，ArrayList<String>只剩下原始类型，泛型信息String不存在了。那么，运行时进行类型查询的时候使用下面的方法是错误的

[java]  view plain  copy

1. if( arrayList instanceof ArrayList<String>)      

java限定了这种类型查询的方式，？为通配符，也即非限定符。

[java]  view plain  copy

1. if( arrayList instanceof ArrayList<?>)      

4、泛型在静态方法和静态类中的问题

泛型类中的静态方法和静态变量不可以使用泛型类所声明的泛型类型参数

[java]  view plain  copy

1. public class Test2<T> {      
2.     public static T one;   //编译错误      
3.     public static  T show(T one){ //编译错误      
4.         return null;      
5.     }      
6. }    

因为泛型类中的泛型参数的实例化是在定义泛型类型对象（例如ArrayList<Integer>）的时候指定的，而静态变量和静态方法不需要使用对象来调用。对象都没有创建，如何确定这个泛型参数是何种类型，所以当然是错误的。

但是要注意区分下面的一种情况：

[java]  view plain  copy

1. public class Test2<T> {      
2.     public static <T >T show(T one){//这是正确的      
3.         return null;      
4.     }      
5. }    

因为这是一个泛型方法，在泛型方法中使用的T是自己在方法中定义的T，而不是泛型类中的T。

泛型相关面试题

1. Java中的泛型是什么 ? 使用泛型的好处是什么?
泛型是一种参数化类型的机制。它可以使得代码适用于各种类型，从而编写更加通用的代码，例如集合框架。

泛型是一种编译时类型确认机制。它提供了编译期的类型安全，确保在泛型类型（通常为泛型集合）上只能使用正确类型的对象，避免了在运行时出现ClassCastException。

2、Java的泛型是如何工作的 ? 什么是类型擦除 ?
泛型的正常工作是依赖编译器在编译源码的时候，先进行类型检查，然后进行类型擦除并且在类型参数出现的地方插入强制转换的相关指令实现的。

编译器在编译时擦除了所有类型相关的信息，所以在运行时不存在任何类型相关的信息。例如List<String>在运行时仅用一个List类型来表示。为什么要进行擦除呢？这是为了避免类型膨胀。

3. 什么是泛型中的限定通配符和非限定通配符 ?
限定通配符对类型进行了限制。有两种限定通配符，一种是<? extends T>它通过确保类型必须是T的子类来设定类型的上界，另一种是<? super T>它通过确保类型必须是T的父类来设定类型的下界。泛型类型必须用限定内的类型来进行初始化，否则会导致编译错误。另一方面<?>表示了非限定通配符，因为<?>可以用任意类型来替代。

4. List<? extends T>和List <? super T>之间有什么区别 ?
这和上一个面试题有联系，有时面试官会用这个问题来评估你对泛型的理解，而不是直接问你什么是限定通配符和非限定通配符。这两个List的声明都是限定通配符的例子，List<? extends T>可以接受任何继承自T的类型的List，而List<? super T>可以接受任何T的父类构成的List。例如List<? extends Number>可以接受List<Integer>或List<Float>。在本段出现的连接中可以找到更多信息。

5. 如何编写一个泛型方法，让它能接受泛型参数并返回泛型类型?
编写泛型方法并不困难，你需要用泛型类型来替代原始类型，比如使用T, E or K,V等被广泛认可的类型占位符。泛型方法的例子请参阅Java集合类框架。最简单的情况下，一个泛型方法可能会像这样:

[java]  view plain  copy

1. public V put(K key, V value) {  
2.     return cache.put(key, value);  
3. }  

6. Java中如何使用泛型编写带有参数的类?
这是上一道面试题的延伸。面试官可能会要求你用泛型编写一个类型安全的类，而不是编写一个泛型方法。关键仍然是使用泛型类型来代替原始类型，而且要使用JDK中采用的标准占位符。
7. 编写一段泛型程序来实现LRU缓存?
对于喜欢Java编程的人来说这相当于是一次练习。给你个提示，LinkedHashMap可以用来实现固定大小的LRU缓存，当LRU缓存已经满了的时候，它会把最老的键值对移出缓存。LinkedHashMap提供了一个称为removeEldestEntry()的方法，该方法会被put()和putAll()调用来删除最老的键值对。
8. 你可以把List<String>传递给一个接受List<Object>参数的方法吗？
对任何一个不太熟悉泛型的人来说，这个Java泛型题目看起来令人疑惑，因为乍看起来String是一种Object，所以List<String>应当可以用在需要List<Object>的地方，但是事实并非如此。真这样做的话会导致编译错误。如果你再深一步考虑，你会发现Java这样做是有意义的，因为List<Object>可以存储任何类型的对象包括String, Integer等等，而List<String>却只能用来存储Strings。

[java]  view plain  copy

1. List<Object> objectList;  
2. List<String> stringList;  
3.         
4. objectList = stringList;  //compilation error incompatible types  

9. Array中可以用泛型吗?
这可能是Java泛型面试题中最简单的一个了，当然前提是你要知道Array事实上并不支持泛型，这也是为什么Joshua Bloch在Effective Java一书中建议使用List来代替Array，因为List可以提供编译期的类型安全保证，而Array却不能。
10. 如何阻止Java中的类型未检查的警告?
如果你把泛型和原始类型混合起来使用，例如下列代码，Java 5的javac编译器会产生类型未检查的警告
，例如List<String> rawList = new ArrayList()
注意: Hello.java使用了未检查或称为不安全的操作;
这种警告可以使用@SuppressWarnings("unchecked")注解来屏蔽。

11、Java中List<Object>和原始类型List之间的区别?
原始类型和带参数类型<Object>之间的主要区别是，在编译时编译器不会对原始类型进行类型安全检查，却会对带参数的类型进行检查，通过使用Object作为类型，可以告知编译器该方法可以接受任何类型的对象，比如String或Integer。这道题的考察点在于对泛型中原始类型的正确理解。它们之间的第二点区别是，你可以把任何带参数的泛型类型传递给接受原始类型List的方法，但却不能把List<String>传递给接受List<Object>的方法，因为会产生编译错误。

12、Java中List<?>和List<Object>之间的区别是什么?
这道题跟上一道题看起来很像，实质上却完全不同。List<?> 是一个未知类型的List，而List<Object>其实是任意类型的List。你可以把List<String>, List<Integer>赋值给List<?>，却不能把List<String>赋值给List<Object>。   

[java]  view plain  copy

1. List<?> listOfAnyType;  
2. List<Object> listOfObject = new ArrayList<Object>();  
3. List<String> listOfString = new ArrayList<String>();  
4. List<Integer> listOfInteger = new ArrayList<Integer>();  
5.         
6. listOfAnyType = listOfString; //legal  
7. listOfAnyType = listOfInteger; //legal  
8. listOfObjectType = (List<Object>) listOfString; //compiler error - in-convertible types  

13、List<String>和原始类型List之间的区别.
该题类似于“原始类型和带参数类型之间有什么区别”。带参数类型是类型安全的，而且其类型安全是由编译器保证的，但原始类型List却不是类型安全的。你不能把String之外的任何其它类型的Object存入String类型的List中，而你可以把任何类型的对象存入原始List中。使用泛型的带参数类型你不需要进行类型转换，但是对于原始类型，你则需要进行显式的类型转换。

[java]  view plain  copy

1. List listOfRawTypes = new ArrayList();  
2. listOfRawTypes.add("abc");  
3. listOfRawTypes.add(123); //编译器允许这样 - 运行时却会出现异常  
4. String item = (String) listOfRawTypes.get(0); //需要显式的类型转换  
5. item = (String) listOfRawTypes.get(1); //抛ClassCastException，因为Integer不能被转换为String  
6.         
7. List<String> listOfString = new ArrayList();  
8. listOfString.add("abcd");  
9. listOfString.add(1234); //编译错误，比在运行时抛异常要好  
10. item = listOfString.get(0); //不需要显式的类型转换 - 编译器自动转换  

通配符

通配符上界

常规使用

[java]  view plain  copy

1. public class Test {  
2.     public static void printIntValue(List<? extends Number> list) {  
3.         for (Number number : list) {  
4.             System.out.print(number.intValue()+" ");   
5.         }  
6.         System.out.println();  
7.     }  
8.     public static void main(String[] args) {  
9.         List<Integer> integerList=new ArrayList<Integer>();  
10.         integerList.add(2);  
11.         integerList.add(2);  
12.         printIntValue(integerList);  
13.         List<Float> floatList=new ArrayList<Float>();  
14.         floatList.add((float) 3.3);  
15.         floatList.add((float) 0.3);  
16.         printIntValue(floatList);  
17.     }  
18. }  

输出：

2 2 
3 0 

非法使用

[java]  view plain  copy

1. public class Test {  
2.     public static void fillNumberList(List<? extends Number> list) {  
3.         list.add(new Integer(0));//编译错误  
4.         list.add(new Float(1.0));//编译错误  
5.     }  
6.     public static void main(String[] args) {  
7.         List<? extends Number> list=new ArrayList();  
8.         list.add(new Integer(1));//编译错误  
9.         list.add(new Float(1.0));//编译错误  
10.     }  
11. }  

List<? extends Number>可以代表List<Integer>或List<Float>，为什么不能像其中加入Integer或者Float呢？

首先，我们知道List<Integer>之中只能加入Integer。并且如下代码是可行的：

[java]  view plain  copy

1. List<? extends Number> list1=new ArrayList<Integer>();  
2. List<? extends Number> list2=new ArrayList<Float>();  

假设前面的例子没有编译错误，如果我们把list1或者list2传入方法fillNumberList，显然都会出现类型不匹配的情况， 假设不成立。

因此，我们得出结论：不能往List<? extends T> 中添加任意对象，除了null。

那为什么对List<? extends T>进行迭代可以呢，因为子类必定有父类相同的接口，这正是我们所期望的。

通配符下界

常规使用

[java]  view plain  copy

1. public class Test {  
2.     public static void fillNumberList(List<? super Number> list) {  
3.         list.add(new Integer(0));  
4.         list.add(new Float(1.0));  
5.     }  
6.     public static void main(String[] args) {  
7.         List<? super Number> list=new ArrayList();   
8.         list.add(new Integer(1));  
9.         list.add(new Float(1.1));  
10.     }  
11. }  

可以添加Number的任何子类，为什么呢？

List<? super Number>可以代表List<T>，其中T为Number父类，（虽然Number没有父类）。如果说，T为Number的父类，我们想List<T>中加入Number的子类肯定是可以的。

非法使用

对List<? superT>进行迭代是不允许的。为什么呢？你知道用哪种接口去迭代List吗？只有用Object类的接口才能保证集合中的元素都拥有该接口，显然这个意义不大。其应用场景略。

无界通配符

知道了通配符的上界和下界，其实也等同于知道了无界通配符，不加任何修饰即可，单独一个“？”。如List<?>，“？”可以代表任意类型，“任意”也就是未知类型。

List<Object>与List<?>并不等同，List<Object>是List<?>的子类。还有不能往List<?> list里添加任意对象，除了null。
常规使用

1、当方法是使用原始的Object类型作为参数时，如下：

[java]  view plain  copy

1. public static void printList(List<Object> list) {  
2.     for (Object elem : list)  
3.         System.out.println(elem + "");  
4.     System.out.println();  
5. }  

可以选择改为如下实现：

[java]  view plain  copy

1. public static void printList(List<?> list) {  
2.     for (Object elem: list)  
3.         System.out.print(elem + "");  
4.     System.out.println();  
5. }  

这样就可以兼容更多的输出，而不单纯是List<Object>,如下：

[java]  view plain  copy

1. List<Integer> li = Arrays.asList(1, 2, 3);  
2. List<String>  ls = Arrays.asList("one", "two", "three");  
3. printList(li);  
4. printList(ls);  

参考：

《Java核心技术 卷一》

http://blog.csdn.net/lonelyroamer/article/details/7868820

http://www.oschina.net/translate/10-interview-questions-on-java-generics

http://www.linuxidc.com/Linux/2013-10/90928.htm

1. 问题来源

今天在刷题时，遇到了需要使用泛型数组的场景。题目是按之字形打印二叉树。这道题目需要交替使用两个栈来解决，我的初始代码为：

ArrayDeque<TreeNode>[] stacks = new ArrayDeque<TreeNode>[2];    //1
stacks[0] = new ArrayDeque<TreeNode>();
stacks[1] = new ArrayDeque<TreeNode>();

• 1
• 2
• 3

而在编译时，代码1报出了如下编译错误：

Cannot create a generic array of ArrayDeque<Integer>.

• 1

理解和解决这个问题的过程中我对Java泛型的理解又深入了一点，所以才有这篇文章。

2. Java“禁止”泛型数组

查阅资料，找到了The Java™ Tutorials: Generics，其中讲到了泛型数组，并说道：除非使用通配符，否则一个数组对象的元素不能是泛型。这么做的原因，是为了防止下述代码产生的类型安全问题：

// Not really allowed.
List<String>[] lsa = new List<String>[10];      //1
Object o = lsa;
Object[] oa = (Object[]) o;
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3));
// Unsound, but passes run time store check
oa[1] = li;

// Run-time error: ClassCastException.
String s = lsa[1].get(0);                       //2

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

如果允许泛型数组的存在（第1处代码编译通过），那么在第2处代码就会报出ClassCastException，因为lsa[1]是List<Integer>。Java设计者本着首要保证类型安全（type-safety）的原则，不允许泛型数组的存在，使得编译期就可以检查到这类错误。

3. 解决方案

但是连Java的设计者也承认，这样在使用上很令人恼火（原文是annoying），所以提供了变向的解决方案：显式类型转换。

3.1 通配符

The Java™ Tutorials: Generics给出的解决方案如下：

List<?>[] lsa = new List<?>[10];                //1
Object o = lsa;
Object[] oa = (Object[]) o;
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3));
// Correct.
oa[1] = li;
// Run time error, but cast is explicit.
String s = (String) lsa[1].get(0);              //2

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

在第1处，用?取代了确定的参数类型。根据通配符的定义以及Java类型擦除的保留上界原则，在2处lsa[1].get(0)取出的将会是Object，所以需要程序员做一次显式的类型转换。

3.2 反射

使用java.util.reflect.Array，可以不使用通配符，而达到泛型数组的效果：

List<String>[] lsa = (List<String>[])Array.newInstance(ArrayList.class, 4);     //1
Object o = lsa;
Object[] oa = (Object[]) o;
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3));
// Correct.
oa[1] = li;
// Run time error, but cast is explicit.
String s = lsa[1].get(0);                                                       //2

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

可以看到，我们利用了Array.newInstance()生成了泛型数组，这里没有使用任何通配符，在第2处也没有做显式的类型转换，但是在第1处，仍然存在显式类型转换。我在牛客网刷题时遇到的问题，就是通过这种方式来解决的。

3.3 总结

要想使用泛型数组，要求程序员必须执行一次显示的类型转换，也就是将类型检查的问题从编译器交给了程序员。实际上Java的设计者正是此意，在(List<String>[])Array.newInstance(ArrayList.class, 4)处会有一个unchecked warning，正是编译器在提醒程序员：这个地方，我不会帮你做类型检查，你要自己小心！。

4. 有趣的问题

在探究泛型数组的过程中，我写了一些实验代码，其中有一段：

List<Integer>[] lsa = (List<Integer>[])Array.newInstance(ArrayList.class, 4);
Object o = lsa;
Object[] oa = (Object[]) o;
List<String> li = new ArrayList<String>();
li.add("asdf");
// Correct.
oa[1] = li;
// Run time error, but cast is explicit.
System.out.println(lsa[1].get(0));  //2

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

这段代码不会在2处抛出ClassCastException，相反，它运行正常，输出的结果是asdf。这打破了我的理解，为什么从一个List<String>中取出一个Integer不会报错呢？

如果将上述代码中参数类型的String与Integer互换：

List<String>[] lsa = (List<String>[])Array.newInstance(ArrayList.class, 4);
Object o = lsa;
Object[] oa = (Object[]) o;
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3));
// Correct.
oa[1] = li;
// Run time error, but cast is explicit.
System.out.println(lsa[1].get(0));  //2

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

2处的ClassCastException就会正常抛出。 
为了找到原因，我查看了这两段代码的字节码。下图是第一段代码的字节码： 

这是第二段代码的字节码： 

问题的原因找到了：第一段代码中，lsa[1].get(0)取出的Integer没有做类型检查（checkcast），而在第二段代码中做了类型检查。 
为什么会这样呢？我分析的原因是：第一段代码中，编译器发现下一行调用PrintStream.println，参数类型还是Object（因为System.out.println()这个方法，对于引用类型只有char[]、String、Object三类参数，没有Integer），所以编译器在此处做了优化，免去了类型检查和类型转换的处理。

5. 总结

• Java为了保证类型安全，牺牲掉了泛型数组的使用灵活性，程序员想使用的话，必须进行显式的类型转换。
• 第4节介绍的问题，表明编译器并不是在泛型被使用的每一处都进行了类型检查与类型转换，还是存在一定优化的。所以我在Java泛型的实现：原理与问题这篇博文中，说“Java的泛型是一种违泛型，编译为字节码时参数类型会在代码中被擦除，单独记录在Class文件的attributes域内，而在使用泛型处做类型检查与类型转换”，最后一句话是不严谨的。

来源：oschina

链接：https://my.oschina.net/u/4385831/blog/4044744