泛型这块确实挺绕的。
通过看thinking java的讲解与百度资料，对泛型数组做一简单总结，共同学习吧。不足之处，请大家指正。

Thinking java中讲解：数组与泛型不能很好的结合，不能实例化具有参数化类型的数据。例如：Peel<Banana>[] peels = new Peel<Banana>[10];这是不行的。

一般解决方案：在任何想要创建泛型数组的地方都使用ArrayList.

要成功创建泛型数组的唯一方式就是创建一个被擦除类型的新数组，然后对其转型。
例如可以创建一个非泛型的数组，然后将其转型：
public static void main(String[] args) {
  
  List<String>[] ls;
  List[]  la = new List[10];//创建非泛型数组
  ls = (List<String>[])la;//将其转型
  ls[0]=new ArrayList<String>();
  
  Object[] objects = ls;
  objects[1] = new ArrayList<Integer>();
  
  List<String>[] spheres =(List<String>[])new List[10];
  for(int i= 0; i<spheres.length;i++)
  {
   spheres= new ArrayList();
  }
  System.out.println(spheres.length);
}

利用反射标记创建泛型数组，是一种不错的方法
public class ArrayOfGeneric<T>
{
        T[] array;
        public ArrayOfGeneric4(Class<T> type, int size) {
                /* to solution array of generic key code! */
                array = (T[]) Array.newInstance(type, size);        
        }
        public T get(int index) {
                return array[index];      
        }  
        public T[] rep() {  
                return array;      
        }           
        public void set(int index, T t) {
                array[index] = t;      
        }
        public static void main(String[] args) {
                        ArrayOfGeneric<Integer> aog = new ArrayOfGeneric<Integer>(Integer.class, 10);
                        Object[] objs = aog.rep();   
                        for (int i = 0; i < 10; i++) {  
                                aog.set(i, i);   
                                System.out.println(aog.get(i));   
                        }      
                        try {  
                                 Integer[] strs = aog.rep();  //用反射的方法好处就在这里，可以用实际类型接收  
                                 System.out.println(strs.length);         
                        }
                        catch (Exception ex) {   
                                  ex.printStackTrace();     
                        }      
        }   
}

学习了！