java：多维通用数组创建

如何在java中创建通用项的多维数组

以班级为例：

class A<T>
  {
    T t;
    public A(T t) { this.t = t; }
  }

A类
{
T；
公共A（T T）{this.T=T；}
}

当我尝试创建多维数组时：

A<String>[][] array = new A<String>[2][3];

A[][]数组=新的A[2][3]；

我得到以下错误：

generic array creation
A<String>[][] array = new A<String>[2][3];
                      ^

通用数组创建
A[][]数组=新的A[2][3]；
^

我尝试了以下方法：

A<String>[][] array = (A<String>[][]) (new Object[2]3]);

A[][]数组=（A[][）（新对象[2]3]）；

但这只是抛出：

java.lang.ClassCastException

有什么办法

---

（我希望有人推荐使用列表。请解释如何使用数组来实现这一点。）

我可以这样做

    @SuppressWarnings("unchecked") 
    A<String>[][] array = (A<String>[][]) Array.newInstance(new A<String>("dummy").getClass(), 2, 3);

@SuppressWarnings（“未选中”）
一个[][]数组=（一个[][]）数组.newInstance（新的一个（“伪”）.getClass（），2，3）；

编辑：

根据@dsg的建议，以下内容跳过了临时对象的创建

    @SuppressWarnings("unchecked") 
    A<String>[][] array = (A<String>[][]) Array.newInstance(A.class, 2, 3);

@SuppressWarnings（“未选中”）
[][]数组=（A[][]）数组.newInstance（A.class，2,3）；

或者（根据@unreputable的建议）

@SuppressWarnings（“未选中”）
A[][]数组=新的A[2][3]；

多亏了这些评论，我才得以拼凑出一个解决方案

正如我们看到的，

A[][]数组=新的A[2][3]不起作用

下面介绍如何构造一个由
a
对象组成的
2x3
数组，该数组可以工作：

// get the class of the basic object
Class c = new A<String>("t").getClass();

// get the class of the inner array
A<String>[] a0 = (A<String>[]) java.lang.reflect.Array.newInstance(c, 0);

// construct the outer array
A<String>[][] array = (A<String>[][]) java.lang.reflect.Array.newInstance(a0.getClass(), 2); 

// fill it with instances of the inner array
for (int i = 0; i < 2; ++ i)
{   
  array[i] = (A<String>[]) java.lang.reflect.Array.newInstance(c, 3); 
}

//获取基本对象的类
c类=新的A（“t”）.getClass（）；
//获取内部数组的类
A[]a0=（A[]）java.lang.reflect.Array.newInstance（c，0）；
//构造外部数组
A[][]数组=（A[][]）java.lang.reflect.array.newInstance（a0.getClass（），2）；
//用内部数组的实例填充它
对于（int i=0；i<2；++i）
{   
array[i]=（A[]）java.lang.reflect.array.newInstance（c，3）；
}

更干净的版本（谢谢@Balla R）：

@SuppressWarnings（“未选中”）
A[][]数组=（A[][]）java.lang.reflect.array.newInstance（A.class，2,3）；
不能简单地创建特定于类型的泛型数组

List<String>[] list = new List<String>[2]; //Illegal
List<?> aa[] = new List<?>[2]; // OK
...
A<?>[][] array = new A<?>[2][3]; // OK
A[0][0] = new A<String>(...);

List[]List=新列表[2]//非法的
列表aa[]=新列表[2]；//好啊
...
A[][]数组=新的A[2][3]；//好啊
A[0][0]=新的A（…）；

这是一篇关于Java1.5泛型的有趣文章，“
嗯，我认为Java数组（从Java6开始）不支持泛型。当我开始用java中的泛型编程时，我最大的“wtf”之一。
为什么不这样做：（非泛型）

并创建一个实用程序类来实现您在
a
中创建的函数（我假设有）。例如：

当您在
A
中使用此选项时：

public class A<T>
{
    T obj;
    public A(T obj) { this.obj = obj; }

    public void someFunction() { ... }
}

公共A类
{
T-obj；
公共A（T obj）{this.obj=obj；}
public void someFunction（）{…}
}

您可以创建一个实用程序类：

public class AUtils
{

    public static <T> void someFunction(T obj)
    {
        // Here your code, applied to obj
    }

}

公共类音频
{
公共静态函数（T obj）
{
//这是您的代码，应用于obj
}
}
新建A[][]
并将其强制转换为A[][]

A类
class A<T> 
{
    T s;

    public A(T t)
    {
        s = t;
    }

    public String getType()
    {
        return s.getClass().toString();
    }

    public T getThing()
    {
        return s;
    }
}

public static void main(String[] args) 
{
    A<?>[][] a = new A<?>[2][3];
    a[0][1] = new A<String>("hi");

    System.out.println(a[0][1].getType());
    System.out.println(a[0][1].getThing());

    A<String> b = (A<String>) a[0][1];
}

{
T-s；
公共A（T）
{
s=t；
}
公共字符串getType（）
{
返回s.getClass（）.toString（）；
}
公共T getting（）
{
返回s；
}
}
公共静态void main（字符串[]args）
{
A[]A=新的A[2][3]；
a[0][1]=新的a（“hi”）；
System.out.println（a[0][1].getType（））；
System.out.println（a[0][1].getting（））；
A b=（A）A[0][1]；
}

输出：

类java.lang.String

嗨

---

您可能需要查看和。坚持使用数组而不是其他集合类型的原因是什么？您正在将对象[]强制转换为A[]，2不兼容。@Gareth McCaughan--数组比列表更容易索引

array[i][j]

比

array.get（i）.get（j）

更清晰。当你编写一个复杂的算法时，这真的很有帮助。有没有一种方法可以在不实例化的情况下获得基本对象的类？虽然我很高兴你能弄明白这一点，但最紧迫的问题仍然是为什么要在使用

ArrayList

时遇到这么多麻烦？不，这就是问题所在。在实例化它之前，没有办法确定它的类型。看到我的答案，你可以使用

A[][]

来创建你的数组。我相信下面的方法也可以使用：`@SuppressWarnings（“未选中”）A[][]数组=（A[]]）java.lang.reflect.array.newInstance（A.class，2,3）`@dsg你们真是太有趣了

Array.newInstance（A.class，2，3）

与

newa[2][3]

完全相同，这太酷了！我想你可以做

A[][]数组=（A[][]）新的A[2][3]是的，但通过这种方式，您将有未选中的强制类型转换警告，以防止添加@SuppressWarnings（“未选中”）
public class A<T>
{
    T obj;
    public A(T obj) { this.obj = obj; }

    public void someFunction() { ... }
}

public class AUtils
{

    public static <T> void someFunction(T obj)
    {
        // Here your code, applied to obj
    }

}

class A<T> 
{
    T s;

    public A(T t)
    {
        s = t;
    }

    public String getType()
    {
        return s.getClass().toString();
    }

    public T getThing()
    {
        return s;
    }
}

public static void main(String[] args) 
{
    A<?>[][] a = new A<?>[2][3];
    a[0][1] = new A<String>("hi");

    System.out.println(a[0][1].getType());
    System.out.println(a[0][1].getThing());

    A<String> b = (A<String>) a[0][1];
}