定义泛型数组
在写程序时，大家可能会遇到类似String[] list = new String[8];的需求，这里可以定义String数组，当然我们也可以定义泛型数组，泛型数组的定义方法为 T[]，与String[]是一致的，下面看看用法：

函数fun1(),定义返回值为T[]，参数为接收的T类型的可变长参数。如果有同学对T...arg的用法不了解，可以去找下JAVA 可变长参数方面的知识。
由于可变长参数在输入后，会保存在arg这个数组中，所以，我们直接把数组返回即可。

1. 对整个数组强制转型的例子(错误方法);

package test;

public class GenericParadigm<T> {

		private T[] array;

		public GenericParadigm(int sz) {
			array = (T[]) new Object[sz];
		}

		public void put(int index, T item) {
			array[index] = item;
		}

		public T get(int index) { return array[index]; }

		public T[] rep() { return array; } //应该在运行时出口做文章

		public static void main (String[] args){

			GenericParadigm gai = new GenericParadigm(10);
	
			// Integer[] ia = gai.rep(); //ClassCastException
	
			Object[] oa = gai.rep(); //只能返回对象数组类型为Object[]
		}

}

实际的运行时对象数组是Object[]，而实际的运行时数组对象可能是T类型。

因此，应该在运行时，数组对象的出口做转型输出，入口方法在编译期已实现类型安全，所以出口方法可以放心强制类型转换，保证成功.

public class GenericArray2 {

	private Object[] array; //维护Object[]类型数组
	
	public GenericArray2(int sz) {
		array = new Object[sz];
	}
	
	public void put(int index, T item) {
	array[index] = item;
	}

	public T get(int index) { return (T)array[index]; }//数组对象出口强转
	
	public T[] rep() { return (T[])array; } //运行时无论怎样都是Object[]类型

	public static void main (String[] args){
		GenericArray gai = new GenericArray(10);
		// Integer[] ia = gai.rep(); //依旧ClassCastException
		Object[] oa = gai.rep(); //只能返回对象数组类型为Object[]
		gai.put(0,11);
		System.out.println(gai.get(0)); // 11 ,出口成功转型
	}
}

2. 通过反射在运行时构出实际类型为type[]的对象数组，避免了类型擦除，从而转换成功，无ClassCastException.

public class GenericArrayWithTypeToken {

   	private T[] array;

   	public GenericArrayWithTypeToken(Class type, int sz) {
   		array = (T[]) Array.newInstance(type, sz);//通过反射在运行时构出实际类型为type[]的对象数组，避免了类型擦除，从而转换成功，无ClassCastException
   	}
   	
   	public void put(int index, T item){
   		array[index] = item;
   	}
   	
   	public T get(int index) { return array[index]; }
   	
   	public T[] rep() { return array; } //能成功返回了~
   	
   		public static void main(String[] args) {
   		GenericArrayWithTypeToken gawtt = new GenericArrayWithTypeToken<>(Integer.class, 10);
   		Integer[] ia = gawtt.rep(); //能成功返回了！
   		}
}

模板

public class ArrayQueue<T> {
    private int front=0;//头部指针，空
    private int rear=0;//尾部指针，有值
    private int maxSize=10;//容量,默认给10
    private T[] array;//数组，存储内容

    public ArrayQueue(Class<T> clazz,int maxSize) {
        this.maxSize = maxSize;
        array = (T[]) Array.newInstance(clazz, maxSize);
    }
}

结论

不能(直接)创建泛型数组

泛型数组实际的运行时对象数组只能是原始类型( T[]为Object[]，Pair[]为Pair[] )，而实际的运行时数组对象可能是T类型( 虽然运行时会擦除成原始类型 )

问题

  首先对比一下以下两段代码，都是声明两个数组，其中一个使用泛型，一个不使用泛型。使用泛型的一个编译失败，由此可知，Java 不支持泛型数组。

List<Integer>[] list = new LinkedList<Integer>[10];// 无法通过编译

List[] list = new LinkedList[10];

原因

  Java 泛型通过类型擦除实现，编译时类型参数就会被擦掉。例如：声明一个 List<String>，一个 List<Integer>，编译后，都变为 List，并且在 JVM 中是同一个 class 对象 List.class。

List<String> stringList = new LinkedList<String>();
List<Integer> integerList = new LinkedList<Integer>();
// 输出true
System.out.println(stringList.getClass()==integerList.getClass());

假设 Java 允许使用泛型数组，我们看看有什么问题。

List<String>[] list = new LinkedList<String>[10];

经过类型擦除后。

List[] list = new LinkedList[10];

接下来我们就可以往数组中放东西了。

list[1] = new LinkedList<String>();	
list[0] = new LinkedList<Integer>();   // 编译通过

  这里就出现问题了，声明的是 LinkedList<String> 类型的数组，但是居然成功放入了一个 LinkedList<Integer>()，这与 Java 协变数组类型有关，出现了类型安全问题，所以 Java 中不支持泛型数组。

  创建泛型数组的唯一方式，是先创建一个擦除类型的数组，然后使用强制类型转型，这种类型转换将产生一个关于未检验的类型转换的编译警告。

List<String>[] list = (LinkedList<String>[]) new LinkedList[10];
list[0] = new LinkedList<String>();
list[1] = new LinkedList<Integer>();// 报错