Question

有没有办法让以下代码在Java中运行？

public class RandomizedQueue<Item> implements Iterable<Item> {  
    private static final int ARRAYSIZE = 8; // default array size
    private Node[] nodeArray;               // contains pointers to the randomized nodes    
    private int size;                       // current size of queue

    private class Node
    {
        private Item item;
        private Node next;
        private Node previos;
    }

    @SuppressWarnings("unchecked")
    public RandomizedQueue()           // construct an empty randomized queue
    {
        nodeArrays = (Node[]) new Object[ARRAYSIZE]; // fix this and everything works!
    }

    // unimportant randomized queue implementation details
    // ...
}

它在nodeArray初始化行的运行时崩溃，出现以下错误：

Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [LRandomizedQueue$Node; at RandomizedQueue.<init>(RandomizedQueue.java:18) at Subset.main(Subset.java:6)。

问题在于我不能使用诸如ArrayList＆lt;＆gt;之类的库数据结构，因为我必须有自定义的重新调整大小规则。另外，我自己也无法实现ArrayList analogue（我的任务中不允许使用其他类）。

代码nodeArray = new Node[ARRAYSIZE];无法在Eclipse中编译，错误为Cannot create a generic array of RandomizedQueue<Item>.Node。

Answer 1

你的问题是：

public class RandomizedQueue实现Iterable {
[...] 私有类Node { 私人物品项目;

首先，您可能希望使用[静态]嵌套类而不是内部类。 Item是一个通用参数，由于您没有使用标准编码约定，因此不明显。 Node需要一个通用参数。所以：

public class RandomizedQueue实现Iterable {
[...] 私有静态类Node { 私人U项;

所以现在你想要一个这些Node<U>的数组。通常情况下，我会说使用List<Node<U>>，但我认为你在这里尝试某种低效率。因此，我们需要制作一个原型的狡猾数组并投射到泛型。

       Node<T>[] nodeArrays = (Node<T>[])new Node[ARRAYSIZE];

假设您确实想直接分配到该字段：

       nodeArrays = (Node<T>[])new Node[ARRAYSIZE];

可能更好的方法是让Node非通用，然后再投射“获取”。

    private static class Node {
       [...]
       Node[] nodeArrays = new Node[ARRAYSIZE];
    [...]
    private T at(int index) {
        return (T)nodeArrays[index];
    }

顺便说一句：如果你要抑制警告，只能抑制一行。这可能需要引入一个临时变量。

Answer 2

Node是一个非静态内部类，这意味着它在外部类的泛型参数的范围内，这也意味着它与外部类的隐式参数化通用参数。

在RandomizedQueue内，Node表示RandomizedQueue<Item>.Node。这意味着它是一个参数化类型。您无法在Java中创建参数化类型的数组。您只能创建原始类型或通配符参数化类型的数组。

那么Node的原始类型是什么？（正如我之前解释的那样，它不仅仅是Node。）您必须使用外部类名明确限定它：RandomizedQueue.Node。

所以解决方案是创建一个原始类型的数组：

nodeArrays = (Node[]) new RandomizedQueue.Node[ARRAYSIZE];

或通配符参数化类型：

nodeArrays = (Node[]) new RandomizedQueue<?>.Node[ARRAYSIZE];

Answer 3

你应该这样做。

Node[] nodeArrays = new Node[ARRAYSIZE];

Answer 4

不要在Node[] nodeArrays = (Node[]) new Object[ARRAYSIZE];构造函数中创建局部变量RandomizedQueue()。

@SuppressWarnings("unchecked")
public RandomizedQueue()           
{
     nodeArray = new Node[ARRAYSIZE]; Now This is fixed 
}

Answer 5

也可以参见内部类Node的参数化。

class RandomizedQueue<Item> implements Iterable<Item> {
private static final int ARRAYSIZE = 8; // default array size
private Node[] nodeArray; // contains pointers to the randomized nodes
private int size; // current size of queue

private class Node<Item> {
    private Item k;
    private Node next;
    private Node previos;

}

public RandomizedQueue() // construct an empty randomized queue
{
    super();
    nodeArray = new Node[ARRAYSIZE];
}

@Override
public Iterator<Item> iterator() {
    // TODO Auto-generated method stub
    return null;
}
}

Inner Class

java中内部类初始化的泛型数组

5 个答案: