qui vi è la traccia del problema intero:
codice:
 È definita la seguente interfaccia relativa ad una lista di oggetti (liberamente ispirata a List<T> di java.util):
public interface Lista<T> extends Iterable<T>{
public int size();
public void clear();
public void addFirst( T elem );
public void addLast( T elem );
public T getFirst();
public T getLast();
public T removeFirst();
public T removeLast();
public boolean isEmpty();
public boolean isFull();
public void sort( Comparator<T> c );
public ListIterator<T> listIterator();
public ListIterator<T> listIterator( int start );
}//Lista
Progettare e sviluppare:
• una classe astratta ListaAstratta<T>, che implementa l’interfaccia Lista<T> e concretizza quanti più
metodi è possibile, e sicuramente equals(), toString(), hashCode()
• una classe concreta ListaConcatenata<T> erede di ListaAstratta<T> e basata su puntatori espliciti. In
particolare, la classe deve realizzare una lista doppiamente concatenata (ogni nodo ha il puntatore al
successivo (next) e al precedente (prior)) in modo da essere “navigabile” indifferentemente “in avanti” o
“indietro”.
Rilevante nella classe ListaConcatenata<T> è l’implementazione del ListIterator<T>. A questo proposito si
suggerisce di introdurre una inner class in cui il cursore (iteratore) può essere null o se non null punta ad un
nodo non ancora processato (situazione più vicina alla “visione astratta” di un iteratore). Il cursore può essere
null in due casi (da distingere): prima del primo elemento o dopo l’ultimo elemento (quest’ultima circostanza si
verifica anche quando la lista è vuota).
Il metodo sort() riceve un oggetto Comparator<T> e ordina, ad esempio con algoritmo bubble sort, la lista.
Attenzione che quando uno scambio è richiesto tra i contenuti di due nodi, vanno scambiate sole le
informazioni. Non toccare i puntatori durante gli scambi.
vi posto il codice che ho creato, a parte qualche piccolo difettuccio che raddrizzerò più tardi, mi interessa ora il funzionamento di Iterator.

innanzi tutto devo implementare l'interfaccia di cui sopra, poi dev realizzare una classe astratta dove poter concretizzare quanti più metodi possibili:
codice:
package progetto1;
import java.util.*;



public abstract class ListaAstratta<T extends Comparable<? super T>> implements Lista<T>{
//                                             _______________
public abstract void sort( Comparator<T> c );//               |                                              
public abstract ListIterator<T> listIterator();//             |
public abstract ListIterator<T> listIterator( int start );//  |_________________
public abstract void addFirst( T elem );//                                      |
public abstract void addLast( T elem );//   DA IMPLEMENTARE IN CLASSE CONCRETA  |
public abstract T getFirst();//                               __________________|
public abstract T getLast();//                                |
public abstract T removeFirst();//                            |
public abstract T removeLast();//                             |
public abstract void add( T elem );//_________________________|

public boolean equals( Object o ){
	if( !(o instanceof ListaAstratta) ) return false;
	if( o==this ) return true;
	ListaAstratta<T> s=(ListaAstratta<T>)o;
	if( s.size()!=this.size() ) return false;
	Iterator<T> it1=this.iterator();
	Iterator<T> it2=s.iterator();
	while( it1.hasNext() ){
		T e1 = it1.next();
		T e2 = it2.next();
		if( !e1.equals(e2)) return false;
	}//while
	return true;
}//equals

public int size(){
	int k=0;
	for (T e : this)
		k++;
	return k;
}//size

public String toString(){
	StringBuilder sb=new StringBuilder(200);
	sb.append('[');
	Iterator<T> it=iterator();
	while( it.hasNext() ){
		sb.append( it.next() );
		if( it.hasNext() ) sb.append(',');
	}
	sb.append(']');
	return sb.toString();
}//toString

public int hashCode(){
	int p=58;
	int h=1;
	for( T e: this )
		h=h*p+e.hashCode();
	return h;	
}//hashCode	

public void clear(){
	Iterator<T> i=this.iterator();
	while( i.hasNext() ) {
		i.next();
		i.remove();
	}		
}//clear
public boolean contains( T elem ){
	for(T e: this){
		if( e.equals(elem) ) return true;
		if( e.compareTo(elem)>0 ) return false;
	}
	return false;
}//contains

public boolean isEmpty(){
	return iterator().hasNext();
}//isEmpty

public boolean isFull(){
	return false;	
}//isFull


public void remove( T elem ){
	Iterator<T> it=this.iterator();
	while( it.hasNext() ){
		T e=it.next();
		if( e.equals( elem ) ){
			it.remove();
			break;
		}
	}
}//remove


}
e qui di seguito vi è la classe concreta della lista doppiamente concatenata, dove ho problemi con l'implementazione dell'iteratore:
codice:
 package progetto1;
import java.util.*;

public class ListaConcatenata <T extends Comparable<? super T>> extends ListaAstratta<T>implements Iterable<T>{
 
private static class Nodo<E>{	
	E info;
	Nodo next;
	Nodo prior;	
    
	public Nodo(){
		info = null;
		next= null;
		prior=null;
	}
    public E getInfo(){return info;}
	
	public Nodo getNext(){return next;}
	
	public Nodo getPrior(){return prior;}
	
	public void setNext(Nodo node){next=node;}
	
	public void setPrior(Nodo node){prior=node;}
	
	public void setInfo(E argomento){info=argomento;}


}


private Nodo <T> first=null, last=null;

private int size=0;



public void sort(Comparator<T> c) {
	if (isEmpty())throw new RuntimeException("ERRORE!-Lista vuota");
	int a = size();
	while (a!=0){
		if (this.compareTo(c)>0)
    
	}
	}

public void add (T elem){
	Nodo<T>nuovo= new Nodo<T>();
	nuovo.info=elem;
	if(first==null||first.info.compareTo(elem)>=0){
		nuovo.next=first;
		first=nuovo;
		first.prior=null;
		if(last == null)last=nuovo;
}
	else 
		if(last.info.compareTo(elem)<=0){
			nuovo.next=null; nuovo.prior=last; last.next=nuovo; last=nuovo;
		}
		else{
			Nodo<T>cor= first.next;
			while(cor!=null) {
		   if(cor.info.compareTo(elem)<0){
			   cor=cor.next;
			   nuovo.next=cor;
			   cor.prior.next=nuovo;
			   cor.prior=nuovo;
		   }
		   size++;
			}
		}
			}//ADD
		 
public  ListIterator<T> listIterator(){
	return null;
	
}//
	
	
	

public  ListIterator<T> listIterator( int start ){return null;}//NO
public  void addFirst( T elem ){}//no
public  void addLast( T elem ){}//no
public  T getFirst(){return null;}//no
public  T getLast(){return null;}//no
public  T removeFirst(){return null;}//no
public  T removeLast(){return null;}//no



@Override
public Iterator<T> iterator() {
	return iterator();
	
}
class Iteratore implements Iterator{

	private Nodo<T> cor=null, pre=null, suc= first;
	//cor o e' null o punta all'ultimo nodo GIA' visitato
	public boolean hasNext(){
		if( cor==null ){
			return first!=null;
		}
		return cor.next!=null;
	}//hasNext
	
	public T next(){
		if( !hasNext() ) 
			throw new NoSuchElementException();
		if( cor==null ) cor=first;
		else{
			pre=cor;
			cor=cor.next;
			suc=suc.next;
		}
		return cor.info;
	}//next
	public void remove(){
		if( pre==cor ) 
			throw new IllegalStateException();
		if( cor==first ){
			first=first.next;
			if( first==null ) last=null;
		}
		else if( cor==last ){
			last=pre;
			last.next=null;
		}
		else{
			pre.next=cor.next;
		}
		cor=pre; //arretra cor
	}//remove
}//Iteratore	*/

}
Non ho capito questo maledetto iteratore come funziona , se qualcuno può aiutarmi lo ringrazio di cuore