[转]java中泛型创建数组的总结

原文：http://blog.csdn.net/sun7545526/article/details/7262486

在java中,不能通过直接通过T[] tarr=new T[10]的方式来创建数组,最简单的方式便是通过Array.newInstance(Classtype,int size)的方式来创建数组例如下面的程序

 

[java]  view plain copy print ?

1. public class ArrayMaker {  
2.     private Class type;  
3.   
4.     public ArrayMaker(Class type) {  
5.         this.type = type;  
6.     }  
7.   
8.     @SuppressWarnings("unchecked")  
9.     T[] createArray(int size) {  
10.         return (T[]) Array.newInstance(type, size);  
11.     }  
12.   
13.     List createList() {  
14.         return new ArrayList();  
15.     }  
16.   
17.       
18.     public static void main(String[] args) {  
19.           
20.         ArrayMaker am2 = new ArrayMaker(Type.class);  
21.         System.out.println(Arrays.asList(am2.createArray(10)));  
22.         System.out.println(Arrays.asList(am2.createList()));  
23.     }  
24.   
25. }  
26.   
27. class Type {  
28.     @Override  
29.     public String toString() {  
30.         return "type";  
31.     }  
32. }  

上面的这个例子比较简单,但是如果你有接触过泛型数组,你便对他的复杂度有一定的了解,由于创建泛型数组比较复杂,所以在实际的应用过程中一般会选择List的对泛型进行存储,如果实在需要使用泛型数组,则需要注意数组的在运行时的类型,think in java这本书中,对泛型数组的处理通过四个小程序对其进行了比较完整的描述

 

程序一:这个程序主要说明了,在使用泛型数组中容易出现的问题,由于书中对于程序的说明比较详细,所以只对程序做引用

 

[java]  view plain copy print ?

1. class Generic {  
2. }  
3.   
4. public class ArrayofGeneric {  
5.     public static void main(String[] args) {  
6.         Generic[] genArr;  
7.           
8.         // genArr = (Generic[]) new Object[] {};  
9.           
10.         // genArr=new Generic[2];  
11.         genArr = (Generic[]) new Generic[2];  
12.         System.out.println(genArr);  
13.     }  
14. }  

程序二:这个程序主要是说明在程序的执行过程中,泛型数组的类型信息会被擦除,且在运行的过程中数组的类型有且仅有Object[],如果我们强制转换成T[]类型的话,虽然在编译的时候不会有异常产生,但是运行时会有ClassCastException抛出

 

 

[java]  view plain copy print ?

1.   
2. public class ArrayOfGeneric2 {  
3.     public T[] ts;  
4.   
5.     public ArrayOfGeneric2(int size) {  
6.         ts = (T[]) new Object[size];  
7.     }  
8.   
9.     public T get(int index) {  
10.         return ts[index];  
11.     }  
12.   
13.     public T[] rep() {  
14.         return ts;  
15.     }  
16.   
17.     public void set(int index, T t) {  
18.         ts[index] = t;  
19.     }  
20.   
21.     public static void main(String[] args) {  
22.         ArrayOfGeneric2 aog2 = new ArrayOfGeneric2(10);  
23.         Object[] objs = aog2.rep();  
24.         System.out.println(objs);  
25.           
26.        // String[] strs = aog2.rep();  
27.         // System.out.println(strs);  
28.     }  
29.   
30. }  

程序三:主要说明在对象中通过用Object[]来保存数据,则生成对象是,可以对其持有的对象在T和object之间进行转换,但是当设计到数组的转换时,还是会报ClassCastException

 

 

[java]  view plain copy print ?

1.   
2. public class ArrayOfGeneric3 {  
3.     Object[] ts;  
4.   
5.     public ArrayOfGeneric3(int size) {  
6.         ts = new Object[size];  
7.     }  
8.   
9.     public T get(int index) {  
10.         return (T) ts[index];  
11.     }  
12.   
13.     public T[] rep() {  
14.         return (T[]) ts;  
15.     }  
16.   
17.     public void set(int index, T t) {  
18.         ts[index] = t;  
19.     }  
20.   
21.     public static void main(String[] args) {  
22.         ArrayOfGeneric3 aog2 = new ArrayOfGeneric3(10);  
23.         Object[] objs = aog2.rep();  
24.         for (int i = 0; i < 10; i++) {  
25.             aog2.set(i, i);  
26.             System.out.println(aog2.get(i));  
27.         }  
28.             Integer[] strs = aog2.rep();  
29.             System.out.println(strs);  
30.     }  
31. }  

程序四:是对泛型数组相对而言比较完美的解决方案

 

 

[java]  view plain copy print ?

1.   
2. public class ArrayOfGeneric4 {  
3.   
4.     T[] ts;  
5.   
6.     public ArrayOfGeneric4(Class type, int size) {  
7.           
8.         ts = (T[]) Array.newInstance(type, size);  
9.     }  
10.   
11.     public T get(int index) {  
12.         return ts[index];  
13.     }  
14.   
15.     public T[] rep() {  
16.         return ts;  
17.     }  
18.   
19.     public void set(int index, T t) {  
20.         ts[index] = t;  
21.     }  
22.   
23.     public static void main(String[] args) {  
24.         ArrayOfGeneric4 aog2 = new ArrayOfGeneric4(Integer.class, 10);  
25.         Object[] objs = aog2.rep();  
26.         for (int i = 0; i < 10; i++) {  
27.             aog2.set(i, i);  
28.             System.out.println(aog2.get(i));  
29.         }  
30.         try {  
31.             Integer[] strs = aog2.rep();  
32.             System.out.println("user Array.newInstance to create generci of array was successful!!!!! ");  
33.         } catch (Exception ex) {  
34.             ex.printStackTrace();  
35.         }  
36.     }  
37. }  

泛型这一章节的内容从擦除开始,觉得都是非常的难懂,如果哪位同志有比较好的建议,希望能不惜指教