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 
Rispondi quotando