What is the proper Java format in a Type array?

Question

I am having format problems which are causing a reject of Java compilation.

This code works in Netbeans, but the Web compile checker refuses to accept it.

I am making an iterator where I want an array of randomly sorted nodes in a linked list.

This iterator is type checked using < Item>. To check it I'm using a < String > for < Item>

Inside the code, for example there is "int[] vals = new int[numEntries]" and that works without complaints. This is a list of intergers. I want a list of Node< Item> objects. You can see that the complaint is it is looking for Node< Item> and finding Node.

[unchecked] unchecked conversion required: RandomizedQueue<Item>.Node<Item>[] found: RandomizedQueue.Node[] where Item is a type-variable: Item extends Object declared in class RandomizedQueue

The line in question is Node< Item>[] ret1 = new Node[numEntries]. Again, the code runs fine in Netbeans and gives correct results. It is just this warning is killing the Web compiler, and I can't figure out how to get around it.

I tried Node< Item>[] = new Node< Item>[numEntries], but that gave an error instead of a warning. I also tried removing the < Item> tags within the subroutine, but that gives me an unchecked conversion at a different point. What is the correct format which will produce no warnings??

    public Iterator<Item> iterator() {
    Iterator<Item> it = new Iterator<Item>() {
        private final Node<Item>[] elements = init1();
        private int indx = 0;

        private Node<Item>[] init1() {
            Node<Item>[] ret1 = new Node[numEntries];
            Node<Item> curr;
            int[] vals = new int[numEntries];
            int i, j, val;
            int[] free = new int[numEntries];
            for( i=0; i<numEntries; i++) {
                free[i] = i;
            }
            for( i=0; i<numEntries; i++) {
                j = numEntries-i;
                val = StdRandom.uniform(j);
                vals[i] = free[val];
                free[val] = free[j-1];
            }

            for( i=0; i<numEntries; i++) {
                curr = head;
                j = vals[i];
                while( j-- > 0) curr = curr.next;
                ret1[i] = curr;
            }
            return ret1;
        }

Answer 1

https://www.javarticles.com/2014/12/arrays-of-parameterized-type.html

Basically you can't have typed arrays, you'll have to use an ArrayList or something else.

That being said, it seems to me like you have some confusion about the purpose of linked lists

So in java Arrays are fixed in size but allow you to instantly look up a value given it's position in the array. This is great if you don't expect the array to change a lot, but if you had an array of 5 characters a,b,c,d,e and wanted to add g in the middle, what you'd have to do is create a new array of size 6, and then copy over all the values and insert the one you wish wherever is needed. Not too bad, but imagine the array had 100,000 characters instead of 5, copying all that can cause performance problems, especially if it happens often

To solve this problem there are linked lists, since values are linked together it's simple to create a new Node for g, point c.next to g, then g.next to d, you don't have to copy a crazy sized array, all is good. Unfortunately you don't have the ability to instantly look up the x'th item, you'd have to get the first item and then call node.next() x times, but in a lot of instances looking up a values based on it's position isn't really needed.

You're storing all the nodes of a linked list in an array, which is redundant and makes the linked list pointless because you might as well just have an array of Items and get the next item by simply incrementing whatever index variable you're using to access the array.

Think about what an Iterator needs to do, it needs to start at the beginning of a list and then iterate through all the values in the list. This is pretty much exactly what a linked list is for, but an array can also do the job. If you wanted to go with linked list, instead of storing an array of Nodes private final Node<Item>[] elements = init1(); all you need to store is the current node private Node currentNode = init1(); -- init1 needs to be changed to return the FIRST node. Then in the iterators next() function you simply do something like

Node<Item> toReturn = currentNode;
currentNode = currentNode.next();
return toReturn;

You could achieve the same thing by abandoning the linked list all together and just using a regular Item[] array private final Item[] elements = init1(); and then using an incrementing index to go through the values, either way the end result is the same.