Ciao a tutti!

Volevo chiedervi se ho implementato correttamente due metodi di un'interfaccia.

Ho questa interfaccia :
(non spaventatevi dal testo troppo lungo , serve solo per spiegarla meglio

public interface Contenitore<T> extends Iterable<T>{
Comparator<T> getComparator();
void setComparatorAndSort(Comparator<T> c);
int size();
void inserisci(T elem);
boolean rimuovi(T elem);
boolean rimuovi(Contenitore<T> l);
void aggiungi(Contenitore<T> l);
}

Un’istanza di Contenitore memorizza al suo interno un insieme di elementi, di tipo generico T, mantenendoli ordinati secondo il criterio stabilito da un apposito oggetto, di tipo Comparator<T>, ricevuto come parametro del proprio costruttore.

Il metodo getComparator() restituisce l’oggetto Comparator utilizzato per ordinare gli elementi contenuti.

Il metodo setComparatorAndSort() consente di cambiare il criterio di ordinamento specificando un nuovo oggetto Comparator. E’ responsabilità del metodo riordinare gli elementi contenuti in accordo al nuovo criterio.


Questo è il mio svolgimento:


public abstract class ContenitoreAstratto<T> implements Contenitore<T>{

//prima mi sono creato un oggetto comparatore

class Comparatore implements Comparator<T>{
public int compare(T o1, T o2){
T elem = o1;
T elem2 = o2;
if(elem<elem2)
return 1;
else if(elem==elem2)
return 0;
else
return -1;
}
}

Comparator<T> comp = new Comparatore();

Cosi ho poi implementato i due metodi

@Override
public Comparator<T> getComparator(){
return comp;
}

@Override
public void setComparatorAndSort(Comparator<T> c){
Iterator<T> it = this.iterator();
LinkedList<T> ll = new LInkedList<T>();
while(it.hasNext()){
T e = it.next();
ll.add(e);
}
Collections.sort(LinkedList<T> ll, Comparator<T> c);
Iterator<T> itl = ll.iterator();
while(itl.hasNext()){
T e = itl.next();
this.inserisci(e);
}

Ho svolto correttamente??

Tante ma Tante Grazie
Ciao