我无法在 Java 中创建泛型数组类型的原因是什么？

Question

Java 不允许我们做的原因是什么

private T[] elements = new T[initialCapacity];

我可以理解 .NET 不允许我们这样做，因为在 .NET 中，值类型在运行时可以具有不同的大小，但在 Java 中，所有类型的 T 都将是对象引用，因此具有大小相同（如果我错了，请纠正我）。

是什么原因？

Answer 1

这是因为 Java 的数组（与泛型不同）在运行时包含有关其组件类型的信息。所以在创建数组的时候一定要知道组件的类型。由于您在运行时不知道T 是什么，因此无法创建数组。

Answer 2

引用：

泛型类型的数组不是 允许，因为它们不健全。这 问题是由于相互作用 Java 数组，不是静态的 声音，但动态检查， 使用泛型，它们是静态的 声音而不是动态检查。 以下是您可以如何利用 漏洞：

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

我们曾提议解决此问题 使用静态安全数组的问题 （又名方差）但被拒绝 为老虎。

--gafter

（我相信是Neal Gafter，但不确定）

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

Answer 3

如果无法提供一个体面的解决方案，恕我直言，您最终会得到更糟糕的结果。

常见的解决方法如下。

T[] ts = new T[n];

被替换为（假设 T 扩展了 Object 而不是另一个类）

T[] ts = (T[]) new Object[n];

我更喜欢第一个例子，但更多的学术类型似乎更喜欢第二个，或者只是不想考虑它。

为什么不能只使用 Object[] 的大多数示例同样适用于 List 或 Collection（受支持），因此我认为它们是非常糟糕的论点。

注意：这是 Collections 库本身无法在没有警告的情况下编译的原因之一。如果您在没有警告的情况下无法支持此用例，那么泛型模型恕我直言，从根本上破坏了某些东西。

Answer 4

这是不可能的原因是Java纯粹在编译器级别实现其泛型，并且为每个类只生成一个类文件。 这称为Type Erasure。

在运行时，编译后的类需要使用相同的字节码来处理它的所有使用。所以，new T[capacity] 完全不知道需要实例化什么类型。

Answer 5

答案已经给出，但如果你已经有一个 T 的实例，那么你可以这样做：

T t; //Assuming you already have this object instantiated or given by parameter.
int length;
T[] ts = (T[]) Array.newInstance(t.getClass(), length);

希望，我能帮上忙， 费迪265

Answer 6

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

有一个很好的概述here。

Answer 7

我喜欢间接给出的答案 通过Gafter。但是，我认为这是错误的。我稍微改变了 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 中创建泛型数组类型。我是不是误解了这个问题？

Answer 8

来自Oracle tutorial：

您不能创建参数化类型的数组。例如，以下代码无法编译：

List<Integer>[] arrayOfLists = new List<Integer>[2];  // compile-time error

以下代码说明了将不同类型插入数组时会发生什么：

Object[] strings = new String[2];
strings[0] = "hi";   // OK
strings[1] = 100;    // An ArrayStoreException is thrown.

如果你用通用列表尝试同样的事情，就会出现问题：

Object[] stringLists = new List<String>[];  // compiler error, but pretend it's allowed
stringLists[0] = new ArrayList<String>();   // OK
stringLists[1] = new ArrayList<Integer>();  // An ArrayStoreException should be thrown,
                                            // but the runtime can't detect it.

如果允许参数化列表的数组，则前面的代码将无法抛出所需的 ArrayStoreException。

对我来说，这听起来很弱。我认为任何对泛型有足够了解的人都会很好，甚至期望在这种情况下不会抛出 ArrayStoredException。

Answer 9

我知道我在这里聚会有点晚了，但我想我可能能够帮助任何未来的谷歌员工，因为这些答案都没有解决我的问题。不过，Ferdi265 的回答帮助很大。

我正在尝试创建自己的链接列表，因此以下代码对我有用：

package myList;
import java.lang.reflect.Array;

public class MyList<TYPE>  {

    private Node<TYPE> header = null;

    public void clear() {   header = null;  }

    public void add(TYPE t) {   header = new Node<TYPE>(t,header);    }

    public TYPE get(int position) {  return getNode(position).getObject();  }

    @SuppressWarnings("unchecked")
    public TYPE[] toArray() {       
        TYPE[] result = (TYPE[])Array.newInstance(header.getObject().getClass(),size());        
        for(int i=0 ; i<size() ; i++)   result[i] = get(i); 
        return result;
    }


    public int size(){
         int i = 0;   
         Node<TYPE> current = header;
         while(current != null) {   
           current = current.getNext();
           i++;
        }
        return i;
    }  

在 toArray() 方法中为我创建了一个泛型类型的数组：

TYPE[] result = (TYPE[])Array.newInstance(header.getObject().getClass(),size());    

Answer 10

就我而言，我只是想要一个堆栈数组，如下所示：

Stack<SomeType>[] stacks = new Stack<SomeType>[2];

由于这是不可能的，我使用以下解决方法：

1. 围绕 Stack 创建了一个非泛型包装类（比如 MyStack）
2. MyStack[] stacks = new MyStack[2] 运行良好

丑陋，但 Java 很高兴。

注意：正如 BrainSlugs83 在对问题的评论中提到的，在 .NET 中完全有可能拥有泛型数组

Answer 11

这是因为泛型是在创建后添加到 java 中的，所以它有点笨拙，因为 java 的原始制造者认为在创建数组时会在创建数组时指定类型。所以这不适用于泛型，所以你必须这样做 E[] 数组=(E[]) 新对象[15]; 这会编译，但会发出警告。

Answer 12

class 可以声明一个 T[] 类型的数组，但它不能直接实例化这样的数组。相反，一种常见的方法是实例化一个 Object[] 类型的数组，然后进行窄转换为 T[] 类型，如下所示：

  public class Portfolio<T> {
  T[] data;
 public Portfolio(int capacity) {
   data = new T[capacity];                 // illegal; compiler error
   data = (T[]) new Object[capacity];      // legal, but compiler warning
 }
 public T get(int index) { return data[index]; }
 public void set(int index, T element) { data[index] = element; }
}

Answer 13

肯定有一个很好的解决方法（也许使用反射），因为在我看来这正是ArrayList.toArray(T[] a) 所做的。我引用：

public <T> T[] toArray(T[] a)

返回一个包含所有 此列表中的元素以正确的顺序排列；的运行时类型 返回的数组是指定数组的数组。如果列表适合 指定数组，在其中返回。否则，一个新数组是 分配有指定数组的运行时类型和大小 这个列表。

因此，一种解决方法是使用此函数，即在数组中创建所需对象的ArrayList，然后使用toArray(T[] a) 创建实际数组。它不会很快，但你没有提到你的要求。

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

Answer 14

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

我能想到的唯一原因是可变参数 - foo(T...)。否则他们可能已经完全清除了泛型数组类型。 （好吧，他们实际上并不需要为可变参数使用数组，因为可变参数在 1.5 之前不存在。这可能是另一个错误。）

所以这是个谎言，你可以通过可变参数实例化泛型数组！

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

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

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

另一方面，我们使用泛型可变参数已有十年了，但天还没塌下来。所以我们可以说这些问题被夸大了。这没什么大不了的。如果允许显式创建泛型数组，我们就会到处出现错误；但我们已经习惯了擦除的问题，我们可以忍受它。

我们可以指向foo2 来驳斥关于规范使我们远离他们声称让我们远离的问题的说法。如果 Sun 有更多的时间和资源开发 1.5，我相信他们可以达成更令人满意的解决方案。

Answer 15

正如其他人已经提到的，您当然可以通过some tricks 创建。

但不推荐。

因为 type erasure 和更重要的 covariance in 数组只允许将子类型数组分配给超类型数组，这会迫使您在尝试取回值时使用显式类型转换导致运行时ClassCastException 这是泛型试图消除的主要目标之一：Stronger type checks at compile time。

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

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

---

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

Answer 16

T 值 []; // 好的

但是，你不能实例化一个 T 的数组 // vals = new T[10]; // 无法创建 T 数组

你不能创建一个 T 数组的原因是没有办法 编译器知道要实际创建什么类型的数组。

Answer 17

试试这个：

List<?>[] arrayOfLists = new List<?>[4];