再看看这段代码:

public static <T> T[] toArray(final List<T> obj) {
    if (obj == null || obj.isEmpty()) {
        return null;
    }
    final T t = obj.get(0);
    final T[] res = (T[]) Array.newInstance(t.getClass(), obj.size());
    for (int i = 0; i < obj.size(); i++) {
        res[i] = obj.get(i);
    }
    return res;
}

它将任何类型的对象的列表转换为相同类型的数组。

你可以这样做:

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

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

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

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

您不需要将Class参数传递给构造函数。 试试这个。

public class GenSet<T> {

    private final T[] array;

    @SafeVarargs
    public GenSet(int capacity, T... dummy) {
        if (dummy.length > 0)
            throw new IllegalArgumentException(
              "Do not provide values for dummy argument.");
        this.array = Arrays.copyOf(dummy, capacity);
    }

    @Override
    public String toString() {
        return "GenSet of " + array.getClass().getComponentType().getName()
            + "[" + array.length + "]";
    }
}

and

GenSet<Integer> intSet = new GenSet<>(3);
System.out.println(intSet);
System.out.println(new GenSet<String>(2));

结果:

GenSet of java.lang.Integer[3]
GenSet of java.lang.String[2]

如果你真的想包装一个固定大小的通用数组，你将有一个方法来添加数据到该数组，因此你可以正确地初始化数组，这样做:

import java.lang.reflect.Array;

class Stack<T> {
    private T[] array = null;
    private final int capacity = 10; // fixed or pass it in the constructor
    private int pos = 0;

    public void push(T value) {
        if (value == null)
            throw new IllegalArgumentException("Stack does not accept nulls");
        if (array == null)
            array = (T[]) Array.newInstance(value.getClass(), capacity);
        // put logic: e.g.
        if(pos == capacity)
             throw new IllegalStateException("push on full stack");
        array[pos++] = value;
    }

    public T pop() throws IllegalStateException {
        if (pos == 0)
            throw new IllegalStateException("pop on empty stack");
        return array[--pos];
    }
}

在这种情况下，您使用java.lang.reflect.Array.newInstance来创建数组，它将不是Object[]，而是一个真正的T[]。 您不应该担心它不是最终的，因为它是在类中管理的。 注意，在push()上需要一个非空对象才能获得要使用的类型，因此我添加了一个对您所推送的数据的检查，并在那里抛出异常。

不过，这有点没有意义:通过push存储数据，方法的签名保证只有T个元素可以进入。所以数组是Object[]还是T[]或多或少是无关紧要的。

我想知道这段代码是否会创建一个有效的泛型数组?

public T [] createArray(int desiredSize){
    ArrayList<T> builder = new ArrayList<T>();
    for(int x=0;x<desiredSize;x++){
        builder.add(null);
    }
    return builder.toArray(zeroArray());
}

//zeroArray should, in theory, create a zero-sized array of T
//when it is not given any parameters.

private T [] zeroArray(T... i){
    return i;
}

编辑:也许另一种创建这样一个数组的方法，如果你所需要的大小是已知的和小的，将是简单地提供所需的“null”的数量到zeroArray命令?

虽然这显然不如使用createArray代码通用。

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

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()返回的数组是正确的类型(即使我们知道)。

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