实际上，更简单的方法是创建一个对象数组，并将其转换为所需的类型，如下例所示:

T[] array = (T[])new Object[SIZE];

其中SIZE是一个常量，T是一个类型标识符

我必须反过来问一个问题:你的发电机组是“检查”还是“未检查”? 这是什么意思?

Checked: strong typing. GenSet knows explicitly what type of objects it contains (i.e. its constructor was explicitly called with a Class<E> argument, and methods will throw an exception when they are passed arguments that are not of type E. See Collections.checkedCollection. -> in that case, you should write: public class GenSet<E> { private E[] a; public GenSet(Class<E> c, int s) { // Use Array native method to create array // of a type only known at run time @SuppressWarnings("unchecked") final E[] a = (E[]) Array.newInstance(c, s); this.a = a; } E get(int i) { return a[i]; } } Unchecked: weak typing. No type checking is actually done on any of the objects passed as argument. -> in that case, you should write public class GenSet<E> { private Object[] a; public GenSet(int s) { a = new Object[s]; } E get(int i) { @SuppressWarnings("unchecked") final E e = (E) a[i]; return e; } } Note that the component type of the array should be the erasure of the type parameter: public class GenSet<E extends Foo> { // E has an upper bound of Foo private Foo[] a; // E erases to Foo, so use Foo[] public GenSet(int s) { a = new Foo[s]; } ... }

所有这些都是由于Java中泛型的一个已知且刻意的弱点:它是使用擦除来实现的，因此“泛型”类不知道它们在运行时是用什么类型参数创建的，因此不能提供类型安全，除非实现了一些显式机制(类型检查)。

下面是如何使用泛型来获得你正在寻找的精确类型的数组，同时保持类型安全(与其他答案相反，后者要么会返回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));
}

一个简单的解决方法是在主类中嵌套第二个“holder”类，并使用它来保存数据。

public class Whatever<Thing>{
    private class Holder<OtherThing>{
        OtherThing thing;
    }
    public Holder<Thing>[] arrayOfHolders = new Holder<Thing>[10]
}

在Java 8中，我们可以使用lambda或方法引用创建一种泛型数组。这类似于反射方法(传递一个类)，但这里我们没有使用反射。

@FunctionalInterface
interface ArraySupplier<E> {
    E[] get(int length);
}

class GenericSet<E> {
    private final ArraySupplier<E> supplier;
    private E[] array;

    GenericSet(ArraySupplier<E> supplier) {
        this.supplier = supplier;
        this.array    = supplier.get(10);
    }

    public static void main(String[] args) {
        GenericSet<String> ofString =
            new GenericSet<>(String[]::new);
        GenericSet<Double> ofDouble =
            new GenericSet<>(Double[]::new);
    }
}

例如，<A> A[] Stream.toArray(IntFunction<A[]>)使用此方法。

这也可以在java 8之前使用匿名类来完成，但是比较麻烦。

Java泛型的工作原理是在编译时检查类型并插入适当的类型转换，但在编译后的文件中删除类型。这使得不理解泛型的代码(这是一个深思熟虑的设计决策)可以使用泛型库，但这意味着您通常无法在运行时找到类型。

公共Stack(Class<T> clazz,int capacity)构造函数要求您在运行时传递Class对象，这意味着类信息在运行时可用于需要它的代码。而Class<T>形式意味着编译器会检查你传递的Class对象是否恰好是类型T的Class对象，不是T的子类，也不是T的超类，而是恰好是T。

这意味着您可以在构造函数中创建适当类型的数组对象，这意味着您存储在集合中的对象的类型将在它们被添加到集合时检查它们的类型。