1

Is there any way to make the following code work in 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
    // ...
}

It crashes on runtime at nodeArray initialization line with the following error:

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

The problem is that I cannot use library data structures such as ArrayList<>, because I got to have custom re-size rules. In addition, I cannot implement ArrayList analogue myself (no additional classes allowed in my task).

Code nodeArray = new Node[ARRAYSIZE]; does not compile in Eclipse with error Cannot create a generic array of RandomizedQueue<Item>.Node.

4

5 回答 5

2

你的问题是这样的：

公共类 RandomizedQueue 实现 Iterable {
[...] private class Node { private Item item;

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

公共类 RandomizedQueue 实现 Iterable {
[...] private static class Node { private U item;

所以现在你想要一个这些Node<U>s 的数组。通常，我会说使用 a List<Node<U>>，但我假设您在这里尝试某种低级效率。所以我们需要制作一个原始类型的狡猾数组并在泛型上进行强制转换。

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

假设您实际上想直接分配给该字段：

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

可能更好的方法是制作Node非泛型，然后对“gets”进行强制转换。

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

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

于 2013-10-24T09:19:49.760 回答
1

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

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

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

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

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

或通配符参数化类型：

nodeArrays = (Node[]) new RandomizedQueue<?>.Node[ARRAYSIZE];
于 2013-10-25T08:49:54.487 回答
0

参见内部类 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;
}
}

内部类

于 2013-10-24T09:32:29.477 回答
0

你应该这样做。

Node[] nodeArrays = new Node[ARRAYSIZE];
于 2013-10-24T09:16:44.980 回答
0

Don't create local variable Node[] nodeArrays = (Node[]) new Object[ARRAYSIZE]; within RandomizedQueue() constructor.

@SuppressWarnings("unchecked")
public RandomizedQueue()           
{
     nodeArray = new Node[ARRAYSIZE]; Now This is fixed 
}
于 2013-10-24T09:19:20.040 回答