Java中泛型創建數組的總結

在java中,不能通過直接通過T[] tarr=new T[10]的方式來創建數組,最簡單的方式便是通過Array.newInstance(Class<t>type,int size)的方式來創建數組例如下面的程序

1. public class ArrayMaker<T> {
2. private Class<T> type;
4. public ArrayMaker(Class<T> type) {
5. this.type = type;
6. }
8. @SuppressWarnings("unchecked")
9. T[] createArray(int size) {
10. return (T[]) Array.newInstance(type, size);
11. }
13. List<T> createList() {
14. return new ArrayList<T>();
15. }
17. /**
18. * @param args
19. */
20. public static void main(String[] args) {
21. /*
22. * Even though kind is stored as Class<T> , erasure means that it is actually just being stored as a Class, with
23. * no parameter. So, when you do some thing with it, as in creating an array, Array.newInstance( ) doesn’t
24. * actually have the type information that’s implied in kind; so it cannot produce the specific result, wh ich
25. * must therefore be cast, which produces a warning that you cannot satisfy.
26. */
27. ArrayMaker<Type> am2 = new ArrayMaker<Type>(Type.class);
28. System.out.println(Arrays.asList(am2.createArray(10)));
29. System.out.println(Arrays.asList(am2.createList()));
30. }
32. }
34. class Type {
35. @Override
36. public String toString() {
37. return "type";
38. }
39. }

上面的這個例子比較簡單,但是如果你有接觸過泛型數組,你便對他的復雜度有一定的了解,由於創建泛型數組比較復雜,所以在實際的應用過程中一般會選擇List的對泛型進行存儲,如果實在需要使用泛型數組,則需要注意數組的在運行時的類型,think in java這本書中,對泛型數組的處理通過四個小程序對其進行了比較完整的描述

程序一:這個程序主要說明了,在使用泛型數組中容易出現的問題,由於書中對於程序的說明比較詳細,所以只對程序做引用

1. class Generic<T> {
2. }
4. public class ArrayofGeneric {
5. public static void main(String[] args) {
6. Generic<Integer>[] genArr;
7. /*
8. * will throw ClassCastException :The problem is that arrays keep track of their actual type, and that type is
9. * established at the point of creation of the array. So even though genArr has been cast to a Generic < Integer
10. * >[] , that information only exists at compile time (and without the @SuppressWarnings annotation, you’d get a
11. * warning for that cast). At run time, it’s still an array of Object, and that causes problems.
12. */
13. // genArr = (Generic<Integer>[]) new Object[] {};
14. /* can not create a generic of array */
15. // genArr=new Generic<Integer>[2];
16. genArr = (Generic<Integer>[]) new Generic[2];
17. System.out.println(genArr);
18. }
19. }

程序二:這個程序主要是說明在程序的執行過程中,泛型數組的類型信息會被擦除,且在運行的過程中數組的類型有且僅有Object[],如果我們強制轉換成T[]類型的話,雖然在編譯的時候不會有異常產生,但是運行時會有ClassCastException拋出

1. /**
2. *
3. * Because of erasure, the runtime type of the array can only be Object[]. If we immediately cast it to T[], then at
4. * compile time the actual type of the array is lost, and the compiler may miss out on some potential error checks.
5. *
6. *
7. *
8. * archive $ProjectName: $
9. *
10. * @author Admin
11. *
12. * @version $Revision: $ $Name: $
13. */
14. public class ArrayOfGeneric2<T> {
15. public T[] ts;
17. public ArrayOfGeneric2(int size) {
18. ts = (T[]) new Object[size];
19. }
21. public T get(int index) {
22. return ts[index];
23. }
25. public T[] rep() {
26. return ts;
27. }
29. public void set(int index, T t) {
30. ts[index] = t;
31. }
33. public static void main(String[] args) {
34. ArrayOfGeneric2<String> aog2 = new ArrayOfGeneric2<String>(10);
35. Object[] objs = aog2.rep();
36. System.out.println(objs);
37. /* will throw ClassCastException */
38. // String[] strs = aog2.rep();
39. // System.out.println(strs);
40. }
42. }