没有人回答你发布的例子中发生了什么。

import java.lang.reflect.Array;

class Stack<T> {
    public Stack(Class<T> clazz, int capacity) {
        array = (T[])Array.newInstance(clazz, capacity);
    }

    private final T[] array;
}

正如其他人所说，泛型在编译过程中被“擦除”。所以在运行时泛型的实例不知道它的组件类型是什么。这样做的原因是历史原因，Sun希望在不破坏现有接口(包括源接口和二进制接口)的情况下添加泛型。

另一方面，数组在运行时知道它们的组件类型。

这个例子通过调用构造函数(构造函数知道类型)的代码传递一个参数，告诉类所需的类型，从而解决了这个问题。

因此，应用程序将用类似于

Stack<foo> = new Stack<foo>(foo.class,50)

构造函数现在知道(在运行时)组件类型是什么，并可以使用该信息通过反射API构造数组。

Array.newInstance(clazz, capacity);

最后，我们有一个类型强制转换，因为编译器无法知道array #newInstance()返回的数组是正确的类型(即使我们知道)。

这种风格有点难看，但它有时是创建泛型类型的最不坏的解决方案，因为无论出于什么原因(创建数组或创建组件类型的实例等)，泛型类型都需要在运行时知道它们的组件类型。

你可以这样做:

E[] arr = (E[])new Object[INITIAL_ARRAY_LENGTH];

这是在Effective Java中实现泛型集合的建议方法之一;26项。没有类型错误，不需要重复强制转换数组。然而，这会触发警告，因为它有潜在的危险，应该谨慎使用。正如注释中所详细描述的，这个对象[]现在伪装成我们的E[]类型，如果不安全使用，可能会导致意外错误或classcastexception。

根据经验，只要强制转换数组在内部使用(例如支持数据结构)，并且不返回或暴露给客户端代码，这种行为是安全的。如果需要向其他代码返回泛型类型的数组，则您提到的反射array类是正确的方法。

值得一提的是，在任何可能的情况下，如果您使用泛型，那么使用列表将比使用数组更愉快。当然，有时您别无选择，但使用集合框架要健壮得多。

这在Effective Java第二版第5章(泛型)第25项中有介绍…更喜欢列表而不是数组

你的代码将会工作，尽管它会生成一个未检查的警告(你可以用下面的注释来抑制它):

@SuppressWarnings({"unchecked"})

然而，使用List而不是Array可能会更好。

在OpenJDK项目网站上有一个关于这个bug/特性的有趣讨论。

我找到了一种快速简便的方法。注意，我只在Java JDK 8上使用了它。我不知道它是否能与以前的版本兼容。

虽然不能实例化特定类型参数的泛型数组，但可以将已经创建的数组传递给泛型类构造函数。

class GenArray <T> {
    private T theArray[]; // reference array

    // ...

    GenArray(T[] arr) {
        theArray = arr;
    }

    // Do whatever with the array...
}

现在在main中，我们可以像这样创建数组:

class GenArrayDemo {
    public static void main(String[] args) {
        int size = 10; // array size
        // Here we can instantiate the array of the type we want, say Character (no primitive types allowed in generics)
        Character[] ar = new Character[size];

        GenArray<Character> = new Character<>(ar); // create the generic Array

        // ...

    }
}

为了更灵活地使用数组，您可以使用链表。数组列表和在Java.util.ArrayList类中找到的其他方法。

下面是如何使用泛型来获得你正在寻找的精确类型的数组，同时保持类型安全(与其他答案相反，后者要么会返回Object数组，要么会在编译时产生警告):

import java.lang.reflect.Array;  

public class GenSet<E> {  
    private E[] a;  

    public GenSet(Class<E[]> clazz, int length) {  
        a = clazz.cast(Array.newInstance(clazz.getComponentType(), length));  
    }  

    public static void main(String[] args) {  
        GenSet<String> foo = new GenSet<String>(String[].class, 1);  
        String[] bar = foo.a;  
        foo.a[0] = "xyzzy";  
        String baz = foo.a[0];  
    }  
}

编译时没有警告，正如你在main中看到的，无论你声明GenSet的实例为什么类型，你都可以将a赋值给该类型的数组，你也可以将a中的元素赋值给该类型的变量，这意味着数组和数组中的值都是正确的类型。

它通过使用类文字作为运行时类型标记来工作，如Java教程中讨论的那样。类字面量被编译器视为java.lang.Class的实例。要使用它，只需在类名后面加上.class。因此，String. Class充当了表示类String的Class对象。这也适用于接口、枚举、任何维度的数组(例如String[].class)、原语(例如int.class)和关键字void(例如void.class)。

Class本身是泛型的(声明为Class<T>，其中T代表Class对象所表示的类型)，这意味着String. Class的类型是Class<String>。

因此，无论何时调用GenSet的构造函数，您都要传入一个类字面量作为表示GenSet实例声明类型的数组的第一个参数(例如String[].class for GenSet<String>)。请注意，您将无法获得一个原语数组，因为原语不能用于类型变量。

Inside the constructor, calling the method cast returns the passed Object argument cast to the class represented by the Class object on which the method was called. Calling the static method newInstance in java.lang.reflect.Array returns as an Object an array of the type represented by the Class object passed as the first argument and of the length specified by the int passed as the second argument. Calling the method getComponentType returns a Class object representing the component type of the array represented by the Class object on which the method was called (e.g. String.class for String[].class, null if the Class object doesn't represent an array).

最后一句不完全准确。调用String[].class.getComponentType()返回一个表示类String的Class对象，但它的类型是Class<?>，而不是Class<String>，这就是为什么你不能做下面这样的事情。

String foo = String[].class.getComponentType().cast("bar"); // won't compile

对于Class中返回Class对象的每个方法也是如此。

关于Joachim Sauer对这个答案的评论(我自己没有足够的声誉来评论它)，使用转换为T[]的示例将导致一个警告，因为在这种情况下编译器不能保证类型安全。

编辑关于Ingo的评论:

public static <T> T[] newArray(Class<T[]> type, int size) {
   return type.cast(Array.newInstance(type.getComponentType(), size));
}

数组不支持泛型(因为它是另一种类型的数据)，但如果你不需要强制转换，你可以在创建它的时候使用未确定的泛型，顺便说一句，它比使用反射要好:

List<?>[] chars = new List[3];

现在我们得到了合法的泛型数组，即使没有Unchecked类型警告，