[JAVA] Implementazione di un comparatore per interfaccia

[Markus85]

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

[VincenzoTheBest]

Originariamente inviato da Markus85
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.

Ciao Markus, in primis ti pongo una domanda:
perchè implementi l'interfaccia usando una classe astratta? visto che il livello di astrazione è già stato alzato mediante l'uso dell'interfaccia stessa..

Per quanto riguarda il comparatore:
questo non deve essere definito all'interno della classe Contenitore, ma come dice la descrizione sopra, viene ricevuto come parametro del proprio costruttore; quindi, nella classe che implementa l'interfaccia Contenitore, devi definire un costruttore con parametro formale di tipo Comparator<T>.

Per quanto riguarda l'implementazione in generale, nella classe che implementa l'interfaccia, devi definire un campo che meglio definisce la rappresentazione del dato Contenitore, altrimenti i vari elementi dove vengono salvati?

[Markus85]

Potresti farmi un esempio di codice su come impostare il comparatore?
Scusami ma ancora non sono tanto pratico nell'uso di java

[VincenzoTheBest]

Originariamente inviato da Markus85
Potresti farmi un esempio di codice su come impostare il comparatore?

Ipotizza di dover confrontare persone.
Quindi hai una classe Persona, ad esempio:

public class Persona{
         private String nome;
         private int eta;

         public Persona(String nome, int eta){
                  this.nome = nome;
                  this.eta = eta;
         }

         public String getNome(){
                  return nome;
         }

         public int getEta(){
                  return eta;
         }
}

Adesso, definisco un comparatore di persone, implementando l'interfaccia java.util.Comparator, volendoli confrontare in base all'età ed al nome, stabilendo come chiave primaria di confronto l'età:

public class PersoneComparator implements Comparator<Persona>{
        public PersoneComparator(){
        }

	public int compare(Persona o1, Persona o2){
                if( o1.getEta() - o2.getEta() != 0 ){
                    if( o1.getEta() > o2.getEta() )
                        return 1;
                    else return -1;
                } else if ( o1.getNome().compareTo(o2.getNome()) != 0) {
                    if( o1.getNome().compareTo(o2.getNome()) > 0 )
                        return 1;
                    else return -1;
                }
                return 0;
        }

        public boolean equals(Object obj){
                 return this.equals(obj);
        }
}

Spero ti sia più chiaro adesso.

[LeleFT]

Come espressamente richiesto dal Regolamento interno, il codice va postato indentato all'interno degli appositi tag CODE (punto 7).

Avrei modificato io il post, se almeno il codice fosse stato indentato, ma così non è...

Sarà per la prossima volta.


Ciao.

[Markus85]

Quindi avrei dovuto fare cosi?

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

public class ComparaPerOrdineNaturaleInverso<T> implements Comparator<T>{

public ComparaPerOrdineNaturaleInverso()
 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 ComparaPerOrdineNaturaleInverso();

@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);
}

protected ContenitoreAstratto<T> creaContenitore();
//Campo che meglio definisce la rappresentazione del contenitore

OK?

[VincenzoTheBest]

Originariamente inviato da Markus85
Quindi avrei dovuto fare cosi?

No, ribadisco che la classe, che implementa l'interfaccia, deve avere un costruttore con un argomento di tipo Comparator<T> (è scritto in quello che hai postato).
Poi non ha senso definire un comparatore per T semplicemente perchè ogni entità ha un suo comparatore.
Ad esempio il comparatore, per confrontare persone, è diverso da quello per confrontare aziende.

[Markus85]

cosi allora:

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

public ContenitoreAstratto(Comparator<T> c){
c = new Comparator<T>();
}

[VincenzoTheBest]

Originariamente inviato da Markus85
cosi allora:

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

public ContenitoreAstratto(Comparator<T> c){
c = new Comparator<T>();
}

No...a parte che così facendo re-istanzi c e non potrai utilizzarlo in nessun modo al di fuori del costruttore, poi non capisco perchè usi una classe astratta.
Dovresti fare in questo modo:

public class MyContenitore<T> implements Contenitore<T>{
         private Comparator<T> comparator;
         //... altri campi

         public MyContenitore(Comparator<T> c){
                  comparator = c;
         }

         //...
}