如何在Java中创建通用数组？

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

但是我真的不知道发生了什么。

我必须问一个问题：您的GenSet“已选中”还是“未选中”？这意味着什么？

• 检查：强打字。GenSet明确地知道什么类型的包含对象（即它的构造是明确要求有Class<E>参数，当他们通过了类型不是参数的方法会抛出异常E。见Collections.checkedCollection。

  ->在这种情况下，您应该写：

  public class GenSet<E> {
  
      private E[] a;
  
      public GenSet(Class<E> c, int s) {
          // Use Array native method to create array
          // of a type only known at run time
          @SuppressWarnings("unchecked")
          final E[] a = (E[]) Array.newInstance(c, s);
          this.a = a;
      }
  
      E get(int i) {
          return a[i];
      }
  }

• 未选中：键入较弱。实际上，不会对作为参数传递的任何对象执行类型检查。

  ->在这种情况下，您应该写

  public class GenSet<E> {
  
      private Object[] a;
  
      public GenSet(int s) {
          a = new Object[s];
      }
  
      E get(int i) {
          @SuppressWarnings("unchecked")
          final E e = (E) a[i];
          return e;
      }
  }

  请注意，数组的组件类型应为type参数的擦除：

  public class GenSet<E extends Foo> { // E has an upper bound of Foo
  
      private Foo[] a; // E erases to Foo, so use Foo[]
  
      public GenSet(int s) {
          a = new Foo[s];
      }
  
      ...
  }

所有这些都是由Java中已知的，有意的泛型弱点导致的：它是使用擦除实现的，因此“泛型”类不知道它们在运行时使用什么类型参数创建，因此无法提供类型-安全，除非实施了一些明确的机制（类型检查）。

你可以这样做：

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

这是在有效Java中实现通用集合的建议方法之一。项目26。没有类型错误，无需重复转换数组。 但是，这会触发警告，因为它有潜在危险，应谨慎使用。如评论中所述，这Object[]现在伪装成我们的E[]类型，ClassCastException如果使用不安全，可能会导致意外错误或s。

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

值得一提的是，List如果使用泛型，那么在可能的情况下，与s而不是数组一起工作的时间会更快乐。当然，有时候您别无选择，但是使用collections框架要健壮得多。

这是在保留类型安全性的同时，使用泛型获取与您正在寻找的类型完全相同的数组的方法（与其他答案相反，其他答案将为您提供Object数组或在编译时产生警告）：

import java.lang.reflect.Array;  

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

    public GenSet(Class<E[]> clazz, int length) {  
        a = clazz.cast(Array.newInstance(clazz.getComponentType(), length));  
    }  

    public static void main(String[] args) {  
        GenSet<String> foo = new GenSet<String>(String[].class, 1);  
        String[] bar = foo.a;  
        foo.a[0] = "xyzzy";  
        String baz = foo.a[0];  
    }  
}

可以在没有警告的情况下进行编译，正如您在中看到的那样main，对于声明GenSetas 实例的任何类型，都可以将其分配a给该类型的数组，并且可以将元素从分配给a该类型的变量，这意味着该数组并且数组中的值是正确的类型。

如Java教程中所述，它通过将类文字用作运行时类型标记来工作。类文字被编译器视为的实例java.lang.Class。要使用一个，只需在类名后面加上即可.class。因此，String.class充当Class表示class 的对象String。这也适用于接口，枚举，任意维数组（例如String[].class），基元（例如int.class）和关键字void（例如void.class）。

Class本身是通用的（声明为Class<T>，其中T代表Class对象表示的类型），表示的类型String.class为Class<String>。

因此，每当您为调用构造函数时GenSet，您都将为第一个参数传入一个类常量，以表示GenSet实例的声明类型的数组（例如，String[].class针对GenSet<String>）。请注意，您将无法获得基元数组，因为基元不能用于类型变量。

在构造函数内部，调用方法cast将传递的Object参数转换为由调用该方法的Class对象表示的类。调用静态方法newInstance在java.lang.reflect.Array返回作为Object由所表示的类型的数组Class作为第一个参数，并通过指定的长度的传递的对象int通过作为第二个参数。调用该方法getComponentType将返回一个Class对象，该对象表示该方法所调用的对象所代表的数组的组件类型Class（例如，String.class对于String[].class，null如果该Class对象不代表数组）。

最后一句话并不完全正确。调用String[].class.getComponentType()返回Class代表该类的对象String，但其类型为Class<?>，而不是Class<String>，这就是为什么您不能执行以下操作的原因。

String foo = String[].class.getComponentType().cast("bar"); // won't compile

Class返回Class对象的每个方法都一样。

关于Joachim Sauer对这个答案的评论（我自己对此没有足够的评价），使用强制转换为的示例T[]将导致警告，因为在这种情况下编译器不能保证类型安全。

编辑有关Ingo的评论：

public static <T> T[] newArray(Class<T[]> type, int size) {
   return type.cast(Array.newInstance(type.getComponentType(), size));
}

这是唯一类型安全的答案

E[] a;

a = newArray(size);

@SafeVarargs
static <E> E[] newArray(int length, E... array)
{
    return Arrays.copyOf(array, length);
}

要扩展更多维度，只需将[]的和维度参数添加到newInstance()（T是类型参数，cls是Class<T>，d1通过d5整数）：

T[] array = (T[])Array.newInstance(cls, d1);
T[][] array = (T[][])Array.newInstance(cls, d1, d2);
T[][][] array = (T[][][])Array.newInstance(cls, d1, d2, d3);
T[][][][] array = (T[][][][])Array.newInstance(cls, d1, d2, d3, d4);
T[][][][][] array = (T[][][][][])Array.newInstance(cls, d1, d2, d3, d4, d5);

有关Array.newInstance()详细信息，请参见。

在Java 8中，我们可以使用lambda或方法引用进行一种通用数组创建。这类似于反射方法（传递a Class），但是这里我们不使用反射。

@FunctionalInterface
interface ArraySupplier<E> {
    E[] get(int length);
}

class GenericSet<E> {
    private final ArraySupplier<E> supplier;
    private E[] array;

    GenericSet(ArraySupplier<E> supplier) {
        this.supplier = supplier;
        this.array    = supplier.get(10);
    }

    public static void main(String[] args) {
        GenericSet<String> ofString =
            new GenericSet<>(String[]::new);
        GenericSet<Double> ofDouble =
            new GenericSet<>(Double[]::new);
    }
}

例如，<A> A[] Stream.toArray(IntFunction<A[]>)。

这可能也可以使用匿名类做预先的Java 8，但它更繁琐。

这是覆盖在第5章（泛型）有效的Java，第二版，第25项...... 不想名单阵列

您的代码可以运行，尽管它会生成未经检查的警告（您可以使用以下注释将其取消：

@SuppressWarnings({"unchecked"})

但是，最好使用List而不是Array。

OpenJDK项目站点上对此错误/功能进行了有趣的讨论。

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

public class GenSet<T> {
    private final T[] array;
    @SuppressWarnings("unchecked")
    public GenSet(int capacity, T... dummy) {
        if (dummy.length > 0)
            throw new IllegalArgumentException(
              "Do not provide values for dummy argument.");
        Class<?> c = dummy.getClass().getComponentType();
        array = (T[])Array.newInstance(c, capacity);
    }
    @Override
    public String toString() {
        return "GenSet of " + array.getClass().getComponentType().getName()
            + "[" + array.length + "]";
    }
}

和

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]

Java泛型通过在编译时检查类型并插入适当的强制转换来工作，但会擦除已编译文件中的类型。这使得泛型库可以通过不理解泛型的代码使用（这是一个有意的设计决策），但是这意味着您通常无法在运行时找出类型。

公共Stack(Class<T> clazz,int capacity)构造函数需要你通过在运行时类对象，这意味着类信息是可在运行时需要它的代码。这种Class<T>形式意味着编译器将检查您传递的Class对象是否恰好是类型T的Class对象。不是T的子类，不是T的超类，而是T。

然后，这意味着您可以在构造函数中创建适当类型的数组对象，这意味着您存储在集合中的对象的类型将在添加到集合时进行类型检查。

嗨，尽管线程已死，但我想提请您注意：

泛型用于在编译期间进行类型检查：

• 因此，目的是检查所需要的东西。
• 您所返回的就是消费者的需求。
• 检查一下：

在编写泛型类时，不必担心类型转换警告。使用时担心。

那这个解决方案呢？

@SafeVarargs
public static <T> T[] toGenericArray(T ... elems) {
    return elems;
}

它的工作原理和看起来太简单，难以置信。有什么缺点吗？

还要看这段代码：

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

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

我找到了一种对我有用的快速简便的方法。请注意，我仅在Java JDK 8上使用过此功能。我不知道它是否可与以前的版本一起使用。

尽管我们无法实例化特定类型参数的泛型数组，但是我们可以将已经创建的数组传递给泛型类构造函数。

class GenArray <T> {
    private T theArray[]; // reference array

    // ...

    GenArray(T[] arr) {
        theArray = arr;
    }

    // Do whatever with the array...
}

现在主要可以像下面这样创建数组：

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

        // ...

    }
}

为了使阵列具有更大的灵活性，您可以使用链表。ArrayList和其他在Java.util.ArrayList类中找到的方法。

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

传递值列表...

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

我编写了此代码段，以反射方式实例化为简单的自动化测试实用程序传递的类。

Object attributeValue = null;
try {
    if(clazz.isArray()){
        Class<?> arrayType = clazz.getComponentType();
        attributeValue = Array.newInstance(arrayType, 0);
    }
    else if(!clazz.isInterface()){
        attributeValue = BeanUtils.instantiateClass(clazz);
    }
} catch (Exception e) {
    logger.debug("Cannot instanciate \"{}\"", new Object[]{clazz});
}

请注意以下部分：

    if(clazz.isArray()){
        Class<?> arrayType = clazz.getComponentType();
        attributeValue = Array.newInstance(arrayType, 0);
    }

用于数组初始化，其中Array.newInstance（array的类，array的大小）。类可以是原始（int.class）和对象（Integer.class）。

BeanUtils是Spring的一部分。

实际上，更简单的方法是创建对象数组并将其转换为所需的类型，如以下示例所示：

T[] array = (T[])new Object[SIZE];

其中SIZE是常量，T是类型标识符

其他人建议的强制演员表对我没有用，这是非法演员表的例外。

但是，此隐式强制转换效果很好：

Item<K>[] array = new Item[SIZE];

其中Item是我定义的包含成员的类：

private K value;

这样，您将获得类型为K（如果项目仅具有值）或想要在类Item中定义的任何通用类型的数组。

没有人回答您发布的示例中发生了什么的问题。

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

最后，我们进行了类型转换，因为编译器无法知道by返回的数组Array#newInstance()是正确的类型（即使我们知道）。

这种样式有点丑陋，但是对于创建泛型类型有时是最坏的解决方案，该泛型类型无论出于何种原因（在创建数组或创建其组件类型的实例等）都需要在运行时知道其组件类型。

我找到了解决该问题的方法。

下面的行引发通用数组创建错误

List<Person>[] personLists=new ArrayList<Person>()[10];

但是，如果我将其封装List<Person>在单独的类中，则它可以工作。

import java.util.ArrayList;
import java.util.List;


public class PersonList {

    List<Person> people;

    public PersonList()
    {
        people=new ArrayList<Person>();
    }
}

您可以通过getter公开PersonList类中的人员。下面的行将为您提供一个数组，List<Person>每个元素中都有一个。换句话说，的数组List<Person>。

PersonList[] personLists=new PersonList[10];

在我正在处理的某些代码中，我需要这样的东西，而这就是我使它起作用的全部工作。到目前为止没有问题。

您可以创建一个Object数组并将其强制转换为E。是的，这样做不是很干净，但至少应该可以。

尝试这个。

private int m = 0;
private int n = 0;
private Element<T>[][] elements = null;

public MatrixData(int m, int n)
{
    this.m = m;
    this.n = n;

    this.elements = new Element[m][n];
    for (int i = 0; i < m; i++)
    {
        for (int j = 0; j < n; j++)
        {
            this.elements[i][j] = new Element<T>();
        }
    }
}

一个简单但杂乱的解决方法是在主类中嵌套第二个“ holder”类，并使用它来保存数据。

public class Whatever<Thing>{
    private class Holder<OtherThing>{
        OtherThing thing;
    }
    public Holder<Thing>[] arrayOfHolders = new Holder<Thing>[10]
}

也许与这个问题无关，但是当我遇到generic array creation使用错误

Tuple<Long,String>[] tupleArray = new Tuple<Long,String>[10];

我发现以下作品（并为我工作） @SuppressWarnings({"unchecked"})：

 Tuple<Long, String>[] tupleArray = new Tuple[10];

我想知道这段代码是否会创建有效的通用数组？

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代码那样通用。

您可以使用强制转换：

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

    public GenSet(int s) {
        a = (Item[]) new Object[s];
    }
}

实际上，我找到了一个非常独特的解决方案来绕过无法启动通用数组的问题。您要做的是创建一个接受通用变量T的类，如下所示：

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

然后在您的数组类中让它像这样开始：

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

开始new Generic Invoker[]会导致未经检查的问题，但实际上应该没有任何问题。

要从数组中获取数据，您应该像这样调用array [i] .variable：

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

根据vnportnoy的语法

GenSet<Integer> intSet[] = new GenSet[3];

创建一个空引用数组，将其填充为

for (int i = 0; i < 3; i++)
{
   intSet[i] = new GenSet<Integer>();
}

这是类型安全的。

private E a[];
private int size;

public GenSet(int elem)
{
    size = elem;
    a = (E[]) new E[size];
}

不允许在Java中创建通用数组，但您可以这样做

class Stack<T> {
private final T[] array;
public Stack(int capacity) {
    array = (T[]) new Object[capacity];
 }
}