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

我找到了一个解决这个问题的方法。
下面这行代码会抛出“泛型数组创建错误”的错误。

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

我在处理一些代码时需要类似这样的东西，这就是我为了让它正常工作所做的。到目前为止没有出现问题。

根据vnportnoy的语法。

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

创建一个空引用数组，以便填充。

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

这是类型安全的。

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

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

我实际上找到了一个非常独特的解决方案，可以绕过初始化通用数组的无能为力。你需要做的是创建一个类，该类接受通用变量T，如下所示：

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

然后在你的数组类中，只需要这样开始：

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

启动一个新的通用调用者[]会导致未检查的问题，但实际上不应该有任何问题。

要从数组中获取，您应该这样调用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++;
}

数组不支持泛型（因为它是另一种类型的数据），但是如果您不需要转换，则可以在创建时使用未确定的泛型，顺便说一下，这比使用反射要好：

List<?>[] chars = new List[3];

现在，我们即使没有Unchecked type警告，也可以获得合法的泛型数组。

你可以创建一个对象数组并将其转换为 E。是的，这不是很干净的方法，但至少应该能够工作。

我在想这段代码是否能创建一个有效的通用数组？

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

也许与这个问题无关，但是当我因为使用泛型数组创建代码而出现“generic array creation”错误时

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

我发现以下代码（对我有效）可以使用 @SuppressWarnings({"unchecked"})：

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

如果您真的想要包装一个固定大小的通用数组，您需要有一个方法来向该数组添加数据，因此您可以在那里正确地初始化数组并执行以下操作：

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[]更或多或少是无关紧要的。