Interfaccia Comparable

[the magician]

Salve a tutti,vi volevo porre questo quesito

import java.util.Comparator;

[code]

public class ComparatorArticoli implements Comparator<Articolo> {

@Override
public int compare(Articolo a, Articolo b) {

Integer inv_1 = a.getInventario();
Integer inv_2 = b.getInventario();
return (inv_1.compareTo(inv_2));
}
public int compare1(Articolo a, Articolo b) {
String coll1 = a.getCollocazione();
String coll2 = b.getCollocazione();
return coll1.compareTo(coll2);
}

}


La domanda è: posso fare una classe fatta così oppure ne devo fare 2 classi distine per ogni compare?

[andbin]

Originariamente inviato da the magician
La domanda è: posso fare una classe fatta così oppure ne devo fare 2 classi distine per ogni compare?

Nel titolo hai messo Comparable e poi hai parlato di Comparator.

Comunque la questione è semplice:
- Comparable va implementato nella classe di cui sono gli oggetti che vuoi comparare/ordinare. Pertanto si può avere 1 solo ordinamento con Comparable e tale ordine fornito da Comparable viene chiamato il "natural ordering" (l'ordinamento "naturale").

- Comparator va implementato in una classe a sé stante, differente da quella di cui sono gli oggetti da comparare. Pertanto di classi che implementano Comparator se ne possono fare quante se ne vogliono.


Riguardo il tuo codice: perché hai messo un metodo compare1() ??? Non serve e non centra nulla con Comparator.

[the magician]

Mi spiego meglio......
Ho sempre da fare questo diavolo di progetto Biblioteca

Quindi faccio la mia classe Articolo

[code]
public class Articolo implements Comparable<Articolo>{
/*
* intero auto incrementato usato per generare il numero di inventario
*/
private static int nArticoli = 1;
public int inventario;
private boolean prestitoAmmesso = true;


// Il numero di scaffale deve esser e >0 quindi fare controlli per inserimento.. ecezzioni
private int nScaffale;


private boolean inPrestito = false;
private int nTessPrestito = 0;

private GregorianCalendar dataPrestito = new GregorianCalendar();
private GregorianCalendar dataFinePrestito = new GregorianCalendar();// deve essere + 15gg

private String titolo;
private String editore;
private String collocazione; //disciplina.nScaffale
private String stato; //al posto di enum
private String disciplina; //al posto di enum
private GregorianCalendar anno = new GregorianCalendar();

/**
* costruttore vuoto
*/

public Articolo(){};

/**
*costruttore della classe, assegna titolo,editore,anno,nScaffale e
*incrementa il numero di inventario
*@param titolo,editore,disciplina,anno,stato,nScaffale
*@throws MyException
*/
public Articolo(String titolo, String editore, String disciplina, int anno, String stato, int nScaffale)
throws MyException{
this.disciplina = disciplina;
this.titolo=titolo;
this.editore=editore;
this.anno.set(Calendar.YEAR, anno);
if(nScaffale <= 0)
throw new MyException ("Il numero di scaffale deve essere > 0");
this.nScaffale = nScaffale;
this.collocazione = disciplina + "." + nScaffale;
this.stato = stato;
inventario = nArticoli;
nArticoli++;
}

public void setPrestitoAmmesso(boolean prestitoAmmesso) {
this.prestitoAmmesso = prestitoAmmesso;
public GregorianCalendar getDataPrestito() {
return dataPrestito;
}*/
/**
* @return collocazione
*/
public String getCollocazione(){
return collocazione;
}

/**
* metodo per l-inizializzazione della data del prestito
* vine chiamato da biblioteca e assegna automaticamente la data corrente
* incrementa automaticamente di 15gg la data del fine prestito
* @param nTess
*/
public void creaPrestitoLibro(int nTess){
inPrestito = true;
nTessPrestito = nTess;
dataPrestito = new GregorianCalendar();
dataFinePrestito = new GregorianCalendar();
dataFinePrestito.add(Calendar.DAY_OF_MONTH, 15);
}

/**
* decrementa il numero di inventario, usato da elimina articolo per mantenere
* la corrispondenza nArticoli ---> inventario.
* MOTIVO: eliminando articoli la variabile nArticoli sarebbe sempre aggiornata
* e potrebbe creare numeri di inventari doppi
*
*/
public void decrementaInventario(){
inventario--;
}
/**
* decrementa nArticoli(numero articoli)
*/
public static void decrementaNarticoli(){
nArticoli--;
}
/**
* azzera il prestio articoli
* cioe' setta le variabili di prestito articolo a 0,false o null a seconda dei tipi primitivi usati
*
*/
public void azzeraPrestitoArticolo(){
inPrestito = false;
nTessPrestito = 0;
dataPrestito = null;
dataFinePrestito = null;
}
/**
* ritorna inventario
* @return inventario
*/
public int getInventario() {
return inventario;
}
/**
* ritorna il numero dello scaffale
* @return nScaffale
*/
public int getNScaffale() {
return nScaffale;
}
/**
* ritorna il numero tessera prestito
* @return nTessPrestito
*/
public int getNTessPrestito() {
return nTessPrestito;
}
/**
* ritorna la data di fine prestito
* @return dataFinePrestito
*/
public GregorianCalendar getDataFinePrestito(){
return dataFinePrestito;
}
/**
* ritorna il giorno della data di fine prestito
* @return dataFinePrestito.get(Calendar.DAY_OF_MONTH)
*/
public int getDataFinePrestitogg() {
return dataFinePrestito.get(Calendar.DAY_OF_MONTH);

}
/**
* ritorna il mese della data di fine prestito
* @return dataFinePrestito.get(Calendar.MONTH)
*/
public int getDataFinePrestitomm() {
return dataFinePrestito.get(Calendar.MONTH);

}
/**
* ritorna l'anno della data di fine prestito
* @return dataFinePrestito.get(Calendar.YEAR)
*/
public int getDataFinePrestitoaa() {
return dataFinePrestito.get(Calendar.YEAR);


/**
* metodo che stampa una serie di variabili di tipi primitivi diversi sotto forma di stringa
* @return titolo,editore,nScaffale,anno,inventario
*/
public String toString(){
String stringa;
stringa="Titolo: "+titolo+ ", Editore: "+editore+ ", Num scaffale: "+nScaffale+
", Anno: "+anno.get(Calendar.YEAR)+ ", Inventario: "+inventario;
return stringa;
}
/**
* metodo che confronta 2 articoli e restituisce 1,0,-1 a seconda se maggiore uguale o minore
* @param Object articolo
* @return -1,0,+1
* @throws ClassCastException
*/
public int compareTo(Articolo art){
return titolo.compareTo(art.getTitolo());
}

/**
* metodo che confronta 2 articoli,restituisce true se sono uguali oppure false
* @param l
* @return true or false
*/
public boolean equals(Articolo art){
boolean uguali=false;
uguali=(this.titolo.equals(art.getTitolo())
&& (this.editore.equals(art.getEditore())));
return uguali;
}
}//fine classe

Il progetto richiede: deve essere possibile specificare diversi criteri di ordinamento: per inventario,per titolo,per collocazione,per autore(utilizzare interfaccia comparator)

Detto questo come faccio a fare un'interfaccia comparator che mi confronti collocazione e inventario? ne devo fare una per collocazione e una per inventario? perchè ho provato ma nel secondo comparator mi da errore....quindi mi riusciresti a dire qual'è la giusta implementazione per il mio caso? Grazie 1000 ancora

[andbin]

Originariamente inviato da the magician
Il progetto richiede: deve essere possibile specificare diversi criteri di ordinamento: per inventario,per titolo,per collocazione,per autore(utilizzare interfaccia comparator)

Detto questo come faccio a fare un'interfaccia comparator che mi confronti collocazione e inventario? ne devo fare una per collocazione e una per inventario?

Sì, devi fare una classe che implementa Comparator<Articolo> per ogni ordinamento particolare.
Nel compare() farai la comparazione dei 2 oggetti ricevuti in base ai criteri specifici per ogni ordinamento.

[the magician]

scusa ancora.....nella gerarchia delle classi ho Libro e Rivista che estendono Articolo, prima ho svolto il progetto senza generics adesso li devo utilizzare
quindi nella classe Libro avevo:
[code]
public class Libro extends Articolo {

private String autore;
private String edizione;
private int nPagine;
public Libro(String titolo, String autore, String disciplina,String editore, int anno,
String edizione, int nPagine, String stato, int nScaffale)
throws MyException{
super(titolo, editore, disciplina, anno, stato, nScaffale);
this.autore=autore;
this.edizione=edizione;
this.nPagine=nPagine;
}
public boolean equals(Object obj){
if(obj instanceof Libro)
return equals ((Libro)obj);
else
return false;
}
public boolean equals(Libro l){
boolean uguali=false;
uguali=(super.equals(l)) && (autore.equals(getAutore()))&& (edizione.equals(getEdizione()));
return uguali;
}
e in Rivista.....
[code]
public class Rivista extends Articolo{

private int numeroRivista;
private int nPagine;
private GregorianCalendar data = new GregorianCalendar();
private String periodicita;
public Rivista(String titolo, String editore, String disciplina,int annoSup, String edizione,
int giorno, int mese, int anno, int numeroRivista, int nPagine, String periodicita,String stato,int nScaffale)
throws MyException{

super(titolo, editore, disciplina, annoSup, stato, nScaffale);

this.data.set(Calendar.DAY_OF_MONTH, giorno);
this.data.set(Calendar.MONTH, mese);
this.data.set(Calendar.YEAR, anno);
this.numeroRivista=numeroRivista;
this.nPagine=nPagine;
this.periodicita = periodicita;

}

public boolean equals(Object obj){
if(obj instanceof Rivista)
return equals ((Rivista)obj);
else
return false;
}
public boolean equals(Object obj){
if(obj instanceof Rivista)
return equals ((Rivista)obj);
else
return false;
}

quindi detto questo come devo modificare queste 2 classi per farle "diventare" generics anche loro?

[the magician]

rigurado alla tua risposta precedente:

Sì, devi fare una classe che implementa Comparator<Articolo> per ogni ordinamento particolare.
Nel compare() farai la comparazione dei 2 oggetti ricevuti in base ai criteri specifici per ogni ordinamento

Quindi devo fare cosi?

public class ComparatorArticoliInv implements Comparator<Articolo> {
public int compare(Articolo a, Articolo b) {
Integer inv_1 = a.getInventario();
Integer inv_2 = b.getInventario();
return (inv_1.compareTo(inv_2));
}

public class ComparatorArticoliCol implements Comparator<Articolo> {
public int compare(Articolo a, Articolo b) {
String coll1 = a.getCollocazione();
String coll2 = b.getCollocazione();
return coll1.compareTo(coll2);
}


non i confronti dentro un unica classe che implementa Comparator?

[andbin]

Originariamente inviato da the magician
quindi detto questo come devo modificare queste 2 classi per farle "diventare" generics anche loro?

Non devi cambiare nulla ..... queste tue classi non sono "generiche", nel senso che non fanno da "contenitore" per un qualunque tipo X.
È il Comparable che usa un tipo parametrico. Ma per il resto non c'è nulla di "generico" in quello che hai scritto.

E giusto per chiarezza: vedo che in Articolo (idem nelle altre classi) hai messo un:
public boolean equals(Articolo art)

Il "vero" equals() è solamente e unicamente

public boolean equals(Object art)

L'utilità di un equals() che prende lo stesso tipo della classe è molto limitata. Dall'esterno della classe verrebbe usato solo se hai un reference Articolo e ci invochi tu esplicitamente equals() passando un altro reference ad un Articolo.

[andbin]

Originariamente inviato da the magician
Quindi devo fare cosi?

public class ComparatorArticoliInv implements Comparator<Articolo> {
public int compare(Articolo a, Articolo b) {
...
public class ComparatorArticoliCol implements Comparator<Articolo> {
public int compare(Articolo a, Articolo b) {
...

Esatto. Io eviterei l'autoboxing e il compareTo. Se i valori sono primitivi, basta un semplice:

return a < b ? -1 : a > b ? +1 : 0;

Originariamente inviato da the magician
non i confronti dentro un unica classe che implementa Comparator?

Appunto. Comparator definisce 1 metodo compare() e solo quello va implementato.

[the magician]

Scusa ancora la pesantezza......
Ma facendo:
[code]
public class ComparatorArticoliInv implements Comparator<Articolo> {

@Override
public int compare(Articolo a, Articolo b) {

Integer inv_1 = a.getInventario();
Integer inv_2 = b.getInventario();
return (inv_1.compareTo(inv_2));
}

e.....
[code]
public class ComparatorArticoliCol implements Comparator {

@Override
public int compare(Articolo a, Articolo b) {
String coll1 = a.getCollocazione();
String coll2 = b.getCollocazione();
return coll1.compareTo(coll2);

Mi da errore....Come mai?

[andbin]

Originariamente inviato da the magician
Mi da errore....Come mai?

Viste così mi sembrano corrette. Puoi essere più preciso? Errore ... quale?