肯定有一个好方法(可能是使用反射)，因为在我看来，这正是数组列表。toArray(T[] a)可以。我引用:

public <T> T[] toArray(T[] a) 返回一个数组，其中包含所有 此列表中的元素按正确顺序排列;的运行时类型 返回的数组是指定数组的数组。如果列表符合 指定的数组，则在其中返回。否则，新数组为 的运行时类型分配 这个列表。

因此，一种方法是使用这个函数，即创建一个数组中你想要的对象的数组列表，然后使用toArray(T[] a)来创建实际的数组。不会很快，但你没提你的要求。

有人知道toArray(T[] a)是如何实现的吗?

主要原因是Java中的数组是协变的。

这里有一个很好的概述。

如果我们不能实例化泛型数组，为什么语言有泛型数组类型?没有对象的类型有什么意义呢?

我能想到的唯一原因是varargs - foo(T…)。否则，它们可以完全删除泛型数组类型。(好吧，他们真的不需要为可变参数使用数组，因为在1.5之前不存在可变参数。这可能是另一个错误。)

所以这是一个谎言，你可以实例化泛型数组，通过varargs!

当然，泛型数组的问题仍然存在，例如。

static <T> T[] foo(T... args){
    return args;
}
static <T> T[] foo2(T a1, T a2){
    return foo(a1, a2);
}

public static void main(String[] args){
    String[] x2 = foo2("a", "b"); // heap pollution!
}

我们可以用这个例子来实际演示泛型数组的危险。

另一方面，我们已经使用泛型变参数10年了，现在还没有崩溃。所以我们可以说问题被夸大了;这没什么大不了的。如果允许显式的泛型数组创建，我们会到处都有bug;但我们已经习惯了擦除的问题，我们可以接受它。

我们可以用foo2来反驳这种说法，即规范让我们避免了他们声称让我们避免的问题。如果Sun在1.5上有更多的时间和资源，我相信他们可以达成一个更令人满意的解决方案。

我喜欢间接给出的答案 Gafter。然而，我认为这是错误的。我稍微修改了一下加福特的代码。它编译并运行一段时间，然后在Gafter预测的地方爆炸

class Box<T> {

    final T x;

    Box(T x) {
        this.x = x;
    }
}

class Loophole {

    public static <T> T[] array(final T... values) {
        return (values);
    }

    public static void main(String[] args) {

        Box<String> a = new Box("Hello");
        Box<String> b = new Box("World");
        Box<String> c = new Box("!!!!!!!!!!!");
        Box<String>[] bsa = array(a, b, c);
        System.out.println("I created an array of generics.");

        Object[] oa = bsa;
        oa[0] = new Box<Integer>(3);
        System.out.println("error not caught by array store check");

        try {
            String s = bsa[0].x;
        } catch (ClassCastException cause) {
            System.out.println("BOOM!");
            cause.printStackTrace();
        }
    }
}

输出为

I created an array of generics.
error not caught by array store check
BOOM!
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
    at Loophole.main(Box.java:26)

在我看来，你可以在java中创建泛型数组类型。我误解了这个问题吗?

引用:

Arrays of generic types are not allowed because they're not sound. The problem is due to the interaction of Java arrays, which are not statically sound but are dynamically checked, with generics, which are statically sound and not dynamically checked. Here is how you could exploit the loophole: class Box<T> { final T x; Box(T x) { this.x = x; } } class Loophole { public static void main(String[] args) { Box<String>[] bsa = new Box<String>[3]; Object[] oa = bsa; oa[0] = new Box<Integer>(3); // error not caught by array store check String s = bsa[0].x; // BOOM! } } We had proposed to resolve this problem using statically safe arrays (aka Variance) bute that was rejected for Tiger. -- gafter

(我相信是尼尔·盖特，但不确定)

在这里查看上下文:http://forums.sun.com/thread.jspa?threadID=457033&forumID=316

正如其他人已经提到的，你当然可以通过一些技巧来创造。

但不建议这样做。

因为类型擦除，更重要的是数组中的协方差，它允许子类型数组被赋给超类型数组，这迫使你在试图取回值时使用显式类型强制转换，导致运行时ClassCastException，这是泛型试图消除的主要目标之一:在编译时进行更强的类型检查。

Object[] stringArray = { "hi", "me" };
stringArray[1] = 1;
String aString = (String) stringArray[1]; // boom! the TypeCastException

一个更直接的例子可以在Effective Java: Item 25中找到。

协方差:如果S是T的子类型，则类型S[]的数组是T[]的子类型