由于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;
}
但我真的不明白这是怎么回事。
当前回答
我找到了一个解决这个问题的方法。
下面这行代码抛出泛型数组创建错误
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];
我需要这样的东西在一些代码中，我正在工作，这就是我所做的让它工作。到目前为止还没有问题。
其他回答
在java中不允许创建通用数组，但是你可以这样做
class Stack<T> {
private final T[] array;
public Stack(int capacity) {
array = (T[]) new Object[capacity];
}
}
我必须反过来问一个问题:你的发电机组是“检查”还是“未检查”? 这是什么意思?
Checked: strong typing. GenSet knows explicitly what type of objects it contains (i.e. its constructor was explicitly called with a Class<E> argument, and methods will throw an exception when they are passed arguments that are not of type E. See Collections.checkedCollection. -> in that case, you should write: 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]; } } Unchecked: weak typing. No type checking is actually done on any of the objects passed as argument. -> in that case, you should write 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; } } Note that the component type of the array should be the erasure of the type parameter: 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中泛型的一个已知且刻意的弱点:它是使用擦除来实现的，因此“泛型”类不知道它们在运行时是用什么类型参数创建的，因此不能提供类型安全，除非实现了一些显式机制(类型检查)。
要扩展到更多维度，只需将[]和维度参数添加到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()。
你可以使用一个类型转换:
public class GenSet<Item> {
private Item[] a;
public GenSet(int s) {
a = (Item[]) new Object[s];
}
}
虽然线程已经死了，但我还是想提请您注意这一点。
泛型用于编译时的类型检查。因此，目的是检查
进来的就是你需要的。 你所返回的就是消费者所需要的。
检查:
在编写泛型类时，不要担心类型转换警告;当你使用它的时候要担心。
