由于Java泛型的实现,你不能有这样的代码:

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

    public GenSet() {
        a = new E[INITIAL_ARRAY_LENGTH]; // error: generic array creation
    }
}

如何在保持类型安全的同时实现这一点?

我在Java论坛上看到一个解决方案是这样的:

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;
}

但我真的不明白这是怎么回事。


当前回答

你可以这样做:

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

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

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


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

其他回答

示例是使用Java反射创建数组。通常不建议这样做,因为它不是类型安全的。相反,您应该做的是使用内部List,并完全避免使用数组。

再看看这段代码:

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;
}

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

实际上,我找到了一个非常独特的解决方案来绕过无法初始化泛型数组的问题。你要做的是创建一个类,它接受泛型变量T,就像这样:

class GenericInvoker <T> {
    T variable;
    public GenericInvoker(T variable){
        this.variable = variable;
    }
}

然后在你的数组类中让它像这样开始:

GenericInvoker<T>[] array;
public MyArray(){
    array = new GenericInvoker[];
}

启动一个新的泛型调用器[]将导致一个未检查的问题,但实际上不应该有任何问题。

要从数组中获取,你应该调用数组[i]。变量如下:

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

剩下的,比如调整数组的大小可以用Arrays.copyOf()来完成,如下所示:

public void resize(int newSize){
    array = Arrays.copyOf(array, newSize);
}

add函数可以这样添加:

public boolean add(T element){
    // the variable size below is equal to how many times the add function has been called 
    // and is used to keep track of where to put the next variable in the array
    arrays[size] = new GenericInvoker(element);
    size++;
}

我找到了一种快速简便的方法。注意,我只在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类中找到的其他方法。

您不需要将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]