Java中泛型创建数组的总结

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

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

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

/**   
 *    
 * Initially, this doesn’t look very different compare with ArrayOfGeneric2.java , just that the cast has been moved.   
 * Without the ©SuppressWarnings annotations, you will still get "unchecked" warnings. However, the internal   
 * representation is now Object[] rather than T[]. When get( ) is called, it casts the object to T, which is in fact the   
 * correct type, so that is safe. However, if you call rep( ) , it again attempts to cast the Object[] to a T[], which   
 * is still incorrect, and produces a warning at compile time and an exception at run time. Thus there’s no way to   
 * subvert the type of the underlying array, which can only be Object[]. The advantage of treating array internally as   
 * Object[] instead of T[] is that it’s less likely that you’ll forget the runtime type of the array and accidentally   
 * introduce a bug (although the majority, and perhaps all, of such bugs would be rapidly detected at run time)   
 *    
 *    
 *    
 * archive $ProjectName: $   
 *    
 * @author Admin   
 *    
 * @version $Revision: $ $Name: $   
 */    
public class ArrayOfGeneric3<T> {    
    Object[] ts;    
    
    public ArrayOfGeneric3(int size) {    
        ts = new Object[size];    
    }    
    
    public T get(int index) {    
        return (T) ts[index];    
    }    
    
    public T[] rep() {    
        return (T[]) ts;    
    }    
    
    public void set(int index, T t) {    
        ts[index] = t;    
    }    
    
    public static void main(String[] args) {    
        ArrayOfGeneric3<Integer> aog2 = new ArrayOfGeneric3<Integer>(10);    
        Object[] objs = aog2.rep();    
        for (int i = 0; i < 10; i++) {    
            aog2.set(i, i);    
            System.out.println(aog2.get(i));    
        }    
            Integer[] strs = aog2.rep();    
            System.out.println(strs);    
    }    
}   
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.

/**   
 *    
 * The type token Class<T> is passed into the constructor in order to recover from the erasure, so that we can create   
 * the actual type of array that we need, although the warning from the cast must be suppressed with @SuppressWarnings.   
 * Once we do get the actual type, we can return it and get the desired results, as you see in main( ). The runtime type   
 * of the array is the exact type T[].   
 *    
 * @author Admin   
 *    
 * @version $Revision: $ $Name: $   
 */    
public class ArrayOfGeneric4<T> {    
    
    T[] ts;    
    
    public ArrayOfGeneric4(Class<T> type, int size) {    
        /* to solution array of generic key code! */    
        ts = (T[]) Array.newInstance(type, size);    
    }    
    
    public T get(int index) {    
        return ts[index];    
    }    
    
    public T[] rep() {    
        return ts;    
    }    
    
    public void set(int index, T t) {    
        ts[index] = t;    
    }    
    
    public static void main(String[] args) {    
        ArrayOfGeneric4<Integer> aog2 = new ArrayOfGeneric4<Integer>(Integer.class, 10);    
        Object[] objs = aog2.rep();    
        for (int i = 0; i < 10; i++) {    
            aog2.set(i, i);    
            System.out.println(aog2.get(i));    
        }    
        try {    
            Integer[] strs = aog2.rep();    
            System.out.println("user Array.newInstance to create generci of array was successful!!!!! ");    
        } catch (Exception ex) {    
            ex.printStackTrace();    
        }    
    }    
}   
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.