Metodi che utilizzano un Comparatore

[Markus85]

Ciao a tutti.

Ho delle difficoltà a scrivere dei metodi che utilizzano un comparatore...

Allora:

Ho la seguente interfaccia :

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

}

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

Ho fatto l'Override di questi metodi ; ditemi se li ho fatti giusti.

Metodo getComparator() che restituisce l'oggetto Comparator utilizzato per ordinare gli elementi contenuti.

abstract class ContenitoreAstratto<T> implements Contenitore<T>{
	
	Comparator<T> comparatore;
	
	@Override
	public Comparator<T> getComparator(){
		return comparatore;
	}

Metodo setComparatorAndSort() che consente di cambiare il criterio di ordinamento specificando un nuovo oggetto Comparator. E' responsabilità di questo metodo riordinare gli elementi contenuti in accordo al nuovo criterio.

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

Non ho capito come scrivere il metodo inserisci() che aggiunge al contenitore l'elemento ricevuto come parametro inserendolo in ordine secondo quanto stabilito dal Comparator attualmente utilizzato.

inoltre non ho capito anche come scrivere il metodo aggiungi() che inserisce in ordine nel contenitore su cui e' invocato tutti gli elementi del contenitore ricevuto come parametro.


Grazie per l'aiuto.
Ciao

[VincenzoTheBest]

Originariamente inviato da Markus85
Non ho capito come scrivere il metodo inserisci() che aggiunge al contenitore l'elemento ricevuto come parametro inserendolo in ordine secondo quanto stabilito dal Comparator attualmente utilizzato.

ContenitoreAstratto deve incapsulare una qualche struttura che ti consente di salvare i dati in memoria.

[Markus85]

Potresti essere più chiaro?

magari mi posti il codice dei metodi inserisci() ed aggiungi().

Quelli che ho fatto io sono giusti?

[VincenzoTheBest]

Originariamente inviato da Markus85
Potresti essere più chiaro?

Ad esempio:

abstract class ContenitoreAstratto<T> implements Contenitore<T>{
	private List<T> contenitore; // ad esempio usi una implementazione di List
	private Comparator<T> comparatore;

        // ... costruttori e metodi
}

Oppure se non puoi utilizzare strutture già pronte, potresti utilizzare array o strutture collegate.

Originariamente inviato da Markus85
magari mi posti il codice dei metodi inserisci() ed aggiungi().

In base al mio suggerimento dovresti essere in grado di implementarli. Se poi incontri dei dubbi, lo fai sapere qui.

Originariamente inviato da Markus85
Quelli che ho fatto io sono giusti?

Conseguentemente a quanto ti ho detto, setComparatorAndSort non è corretto.

[Markus85]

Meglio se mi posti il codice dei metodi

[VincenzoTheBest]

Originariamente inviato da Markus85
Meglio se mi posti il codice dei metodi

Se ti è consentito utilizzare implementazioni di java.util.List, allora la realizzazione dei metodi è decisamente banale.
Ad esempio, potresti ridefinire il metodo inserisci, in questo modo:

@Override
public void inserisci(T elem) {
   if( !this.contenitore.contains(elem) )
       this.contenitore.add( elem );
}

evitando che dunque il contenitore contenga doppioni.
Se invece i duplicati sono ammessi, allora il controllo non ti serve.

[Markus85]

E se io modificassi il metodo setComparatorAndSort() utilizzando una TreeSet e passandogli il comparatore?

@Override
	public void setComparatorAndSort(Comparator<T> c){
		Iterator<T> it = this.iterator();
		TreeSet<T> ll = new TreeSet<T>(c);
		while(it.hasNext()){
			T elem = it.next();
			ll.add(elem);
		}
		Iterator<T> itl = ll.iterator();
		while(itl.hasNext()){
			T elem2 = itl.next();
			this.inserisci(elem2);
		}
		
	}

Ricordando che questo Metodo consente di cambiare il criterio di ordinamento specificando un nuovo oggetto Comparator. E' responsabilità di questo metodo riordinare gli elementi contenuti in accordo al nuovo criterio.

Potrei lasciare astratto il metodo inserisci()?

[VincenzoTheBest]

Originariamente inviato da Markus85
E se io modificassi il metodo setComparatorAndSort() utilizzando una TreeSet e passandogli il comparatore?

@Override
	public void setComparatorAndSort(Comparator<T> c){
		Iterator<T> it = this.iterator();
		TreeSet<T> ll = new TreeSet<T>(c);
		while(it.hasNext()){
			T elem = it.next();
			ll.add(elem);
		}
		Iterator<T> itl = ll.iterator();
		while(itl.hasNext()){
			T elem2 = itl.next();
			this.inserisci(elem2);
		}
		
	}

In questo modo il nuovo ordinamento non verrà visto all'esterno, perchè istanzi un nuovo TreeSet che al di fuori di questo ambiente non è visibile, poi manca l'assegnamento del comparatore.
Quindi, il TreeSet deve essere un campo di istanza (ad esempio lo chiami contenitore) e nel momento in cui deve essere eseguito un nuovo ordinamento (in setComparatorAndSort), ti crei una nuova istanza di TreeSet e dopo aver inserito tutti gli elementi passi questo nuovo oggetto a contenitore.

Nel caso in cui volessi utilizzare una lista come campo di istanza (come da mio esempio), il metodo setComparatorAndSort, puoi farlo così:

@Override
public void setComparatorAndSort(Comparator<T> c){
      Collections.sort(this.contenitore, c);
      this.comparatore = c;
}

N.B. Devi chiedere al tuo prof. se puoi utilizzare strutture già "pronte" per implementare l'interfaccia Contenitore.

[Markus85]

No , non posso utilizzare strutture già pronte.

Cmq , ci ho ragionato meglio ed ho fatto cosi:

[CODE]

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

private TreeSet<T> Collezione;


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

Comparator<T> comparatore;

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

@Override
public void setComparatorAndSort(Comparator<T> c){
ContenitoreAstratto<T> cont = new ContenitoreAstratto<T>();

//Eclipse mi segna in rosso dopo il new "ContenitoreAstratto" con il seguente errore : Cannot instantiate the type ContenitoreAstratto<T>

Iterator<T> it = this.iterator();
While(it.hasNext()){
T elem = it.next();
cont.inserisci(elem);
}
Iterator<T> itc = cont.iterator();
while(itc.hasNext()){
T elem2 = itc.next();
this.inserisci(elem2);
}
}

[Markus85]

No , non posso utilizzare strutture già pronte.

Cmq , ci ho ragionato meglio ed ho fatto cosi:

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

private TreeSet<T> Collezione;


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

Comparator<T> comparatore;

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

@Override
public void setComparatorAndSort(Comparator<T> c){
ContenitoreAstratto<T> cont = new ContenitoreAstratto<T>();

//Eclipse mi segna in rosso dopo il new "ContenitoreAstratto" con il seguente errore : Cannot instantiate the type ContenitoreAstratto<T>

Iterator<T> it = this.iterator();
While(it.hasNext()){
T elem = it.next();
cont.inserisci(elem);
}
Iterator<T> itc = cont.iterator();
while(itc.hasNext()){
T elem2 = itc.next();
this.inserisci(elem2);
}
}