循环链表和迭代器

Question

I'm having trouble with getting my iterator to actually work and test out my add and next method. I was wondering if anyone can point out what i am missing. I been working at it for awhile and can't seem to figure out how to initialize the object correctly, kept saying cannot resolve to a type. Thank You this is my main class

public class CircularList<E> { 
private int size = 0;

//Inner Class
private static class Node<E>{
    private E data;
    private Node<E> next=null;
    private Node<E> previous=null;

    private Node(E dataItem) {
        data = dataItem;
    }
}


//Iterator
public class CircleIter implements ListIterator<E>{
    private Node<E> nextItem;
    private Node<E> lastItemReturned;
    private int index = 0;

public CircleIter(){
    nextItem=null;
    lastItemReturned=null;
}

@Override
public void add(E data) {
    Node<E> newNode = new Node<E>(data);
    if(index==0){
        newNode.next=newNode;
        newNode.previous=newNode;
        nextItem=newNode;
        lastItemReturned=newNode;
    }
    else{
        newNode.previous=nextItem.previous;
        nextItem.previous.next=newNode;
        newNode.next=nextItem;
        nextItem.previous=newNode;

    }
    index++;
    size++;
}

@Override
public boolean hasNext() {
    return nextItem != null;
}

@Override
public boolean hasPrevious() {
    return (lastItemReturned.next == null && size != 0)
            || lastItemReturned.previous != null;
}

@Override  //need to look over
public E next() {
   if (!hasNext()) {
        throw new NoSuchElementException();
   }
  lastItemReturned = nextItem;
  nextItem = nextItem.next;
  index++;
  return lastItemReturned.data;
}
@Override
public int nextIndex() {
    return index;
}

@Override //need to look over
public E previous() {
    nextItem=lastItemReturned;
    lastItemReturned=lastItemReturned.previous;
    index--;
    return nextItem.data;
}
@Override
public int previousIndex() {
    return index-1;
}

//remove last item returned through next&previous method
@Override
public void remove() {
      if (lastItemReturned == null) {
          throw new IllegalStateException();
        }
      nextItem.previous=lastItemReturned.previous;
      lastItemReturned.previous.next=nextItem;
      index--;
      size--;
      lastItemReturned = nextItem.previous;

}

@Override
public void set(E node) {
      if (lastItemReturned == null) {
          throw new IllegalStateException();
        }
        lastItemReturned.data = node;       
}

}  //end of iterator class

}

My Test Class

import CircularList.CircleIter;

public class CircularListTest {
public static void main(String[] args) {
    CircularList<Integer> intList = new CircularList<Integer>();

    CircleIter<Integer> iter= intList.CircleIter<Integer>();
    iter.add(5);


  }
}

Answer 1

If you want to create an instance of CircularList.CircleIter class you should use operator "new".
CircularList.CircleIter is inner class (non-static nested class) of CircularList class so in order to create new instance of it you should provide instance of enclosing class with special syntax :
CircularList<Integer>.CircleIter iter = intList.new CircleIter();
Usually collections expose special method for iterator creating (for example, iterator() method in List) to hide this syntax from consumers.
As Alex Sou mentioned earlier, only enclosing class is parametrized in your difinition.