I trying to write a class that is my own personal LinkedList class . I am having problems getting two methods to work correctly . Any suggestions on what I am doing wrong on the following methods .

1. Iterator<E> iterator
// writing my own version of Iterator with a hasNext() , Next(), Remove(). I keep on getting reference to Java’s Iterator and not mine ?
2. Reverse ()
// Writing a method that takes my LinkedList and reverses the order via object reference (pointers) . I go through the method on a whiteboard and I feel like the references do change . When I go to run it tough I get a list that just decreases . i.e. 1 2 3 4 then becomes 2 3 4 .

OK , any suggestions would be appreciated . Thank you.

Here are my three classes:

Java Code:
//import java.util.Iterator;


class TestListv2 {
  public static void main(String [ ] args) {


 LinkedList383<Integer> ll = new LinkedList383<Integer>( );
 for (int i=0; i<11; i++)
   ll.add(i);
 int counter = 0;

 
 for (Iterator<Integer>iterator it = ll.iterator( ); it.hasNext( ); ;){
   System.out.println(it.next( ));
   if (counter++ == 5) it.remove( );
 }

 System.out.println(ll);
 ll.reverse();
 System.out.println(ll);
    }
}
Java Code:
//import java.util.Iterator;

public class LinkedList383<E> {
  private LinkedListv2<E> front;
  private LinkedListv2<E> back;

  public LinkedList383( ) {
    front = new LinkedListv2<E>( );
    back = new LinkedListv2<E>(null, null, front);
    front.setNext(back);
  }

 

  public void reverse (){
      front.reverse();
  }

  public boolean add(E data) {
    LinkedListv2<E> newLL = new LinkedListv2<E>(data, back, back.getPrevious( ));
    back.getPrevious( ).setNext(newLL);
    back.setPrevious(newLL);
    return true;
  }

  public void add(int index, E data) throws IndexOutOfBoundsException {
	front.add(index,data);
  }

  public E set(int index, E data) throws IndexOutOfBoundsException {
	return front.set(index,data);
  }

  public boolean remove(E data) {
	return front.remove(data);
  }

  public boolean remove(int index) throws IndexOutOfBoundsException {
	return front.remove(index);
  }

  public boolean contains(E data) {
	return front.contains(data);
  }

  public E get(int index) throws IndexOutOfBoundsException  {
	return front.get(index);
  }

  
  public String toString( ) {
	return front.toString( );
  }

   public E iterator(int index) {
       return front.get(index);
    }
}
Java Code:
// version 2 of LinkedList:  doubly linked

// in this version, there is an object with null data at both the front and the back of the list

//import java.util.*;

public class LinkedListv2<E> {
  private E data;
  private LinkedListv2<E> next;
  private LinkedListv2<E> previous;
  // first and last object (front and back of the list) ALWAYS have data == null

  // also must call setupBack
  public LinkedListv2( ) {
    data = null;
    next = null;
  }

  public void setupBack( ) {
	LinkedListv2<E> back = new LinkedListv2<E>(null, null, this);
	next = back;
  }

  public LinkedListv2(E d, LinkedListv2<E> n, LinkedListv2<E> p) {
    data = d;
    next = n;
    previous = p;
  }

  // a couple of getters and setters needed for LinkedList383<E>
  public LinkedListv2<E> getNext( ) { return next; }
  public LinkedListv2<E> getPrevious( ) { return previous; }
  public void setNext(LinkedListv2<E> n) { next = n; }
  public void setPrevious(LinkedListv2<E> p) { previous = p; }

  // Itterator 
  
   public Iterator<E> iterator( ) {
	return new Iterator<E>( ) {
	  private LinkedListv2<E> node = LinkedListv2.this;

	  public boolean hasNext( ) { 


           while(node.next != null){
           node = node.next;
          
          }
           return true;   
          
      }       
    
	  public E next( ) {

       if ( node !=null)
           node = next.next;
       return node.data;


       /*previous = node;
		node = node.next;
		return node.data;
        */


	  }

	  public void remove( ) {


        previous.next = node.next;
	    node.next = node.previous;


         }
    };
  }

// revers the items in the list

   public void reverse ( ) {



       LinkedListv2<E> current = this.next;

        while(current != null){

            next = current.next;
            current.next = current.previous;
            current.previous = next;
            
            if (current == null){

                current.previous = current.next;
                current = this;
                
                //next = current.previous;
            }
            
             current = current.next;
            
          }

      }


  // add in front of blank back of the list
  public boolean add(E newData) {
    LinkedListv2<E> current = next;
    while (current.next != null)
      current = current.next;
    LinkedListv2<E> newLL = new LinkedListv2<E>(newData, current, current.previous);
    current.previous.next = newLL;
    current.previous = newLL;
    return true;
  }


  public void add(int index, E newData) throws IndexOutOfBoundsException {
    // find where to add
    LinkedListv2<E> current = next;
    for (int i=0; i<index; i++) {
      if (current.next == null) throw new IndexOutOfBoundsException( );
      current = current.next;
    }
    LinkedListv2<E> newLL = new LinkedListv2<E>(newData, current, current.previous);
    current.previous.next = newLL;
    current.previous = newLL;
  }

  public E set(int index, E newData) throws IndexOutOfBoundsException {
    // find where to set
    LinkedListv2<E> current = next;
    for (int i=0; i<index; i++) {
      if (current.next == null) throw new IndexOutOfBoundsException( );
      current = current.next;
    }
    if (current.data == null) throw new IndexOutOfBoundsException( );
    E oldData = current.data;
    current.data = newData;
    return oldData;
  }

  public boolean remove(E goneData) {
	// find goneData in the list
	LinkedListv2<E> current = next;
	while (current.next != null && !current.data.equals(goneData))
	  current = current.next;
    if (current.next == null) return false;
    current.previous.next = current.next;
    current.next.previous = current.previous;
    return true;
  }


  public boolean remove(int index) throws IndexOutOfBoundsException {
	// find goneData in the list
	LinkedListv2<E> current = next;
	for (int i=0; i<index; i++) {
      if (current.next == null) throw new IndexOutOfBoundsException( );
	  current = current.next;
    }
    if (current.data == null) throw new IndexOutOfBoundsException( );
    current.previous.next = current.next;
    current.next.previous = current.previous;
    return true;
  }

  public boolean contains(E someData) {
	// find someData in the list
	LinkedListv2<E> current = next, previous = this;
	while (current.next != null && !current.data.equals(someData)) {
	  previous = current;
	  current = current.next;
    }
    return current != null;
  }

  public E get(int index) throws IndexOutOfBoundsException {
    // find location
    LinkedListv2<E> current = next;
    for (int i=0; i<index; i++) {
      if (current.next == null) throw new IndexOutOfBoundsException( );
      current = current.next;
    }
    if (current.data ==  null) throw new IndexOutOfBoundsException( );
    return current.data;
  }

  public String toString( ) {
	String answer = "[ ";
	LinkedListv2<E> current = next;
	while (current.next != null) {
	  answer += current.data.toString( ) + ", ";
	  current = current.next;
	}
	return answer + "]";
  }


}