[java] - oridnamento HashMap

[simo7784]

Mettiamo che le chiavi siano stringhe.

HashMap mappa = new HashMap();
//ALTRO CODICE
Object[] tmp = mappa.keyset().toArray();
String valoreNellArray = null;
for(int i=0; i<tmp.length; i++) {
   valoreNellArray = (String)tmp[i];
   //Ci fai quel che vuoi.
}

Sinceramente non mi sembra una buona strada da percorrere nel tuo caso. Se hai la pazienza di rispondere alle domende che ho fatto sopra, guardiamo se si puo' trovare una via migliore.

[melmar20]

Ciao simo7784 grazie del tuo aiuto.

in pratica devo utilizzare un HashMap
1)perchè ormai mi sono intestardito e devo riuscirci!!
2)perchè mi serve per completare un progetto che ne richiede esplicitametne l'utilizzo.

L'ordinamento devo farlo in base a due parametri presenti negli oggetti dell'HashMap.Questi due parametri che poi sono attributi degli oggetti contenuti nell'HashMap sono Nome e Cognome.

Mi viene riciesto di ordinare gli oggetti secondo questi parametri e poi stamparli.

Avevo pensato di popolare un array con le chiavi in modo tale da poter accedere all'hashMap e poi ordinare i valori dell'array.In questo modo ho un array con gli indici dell'HashMap ordinato come lo desidero.quindi posso andare a leggere la prima chiave e ricavare il valore del primo oggetto(cioè la persona che ha cognome che precede tutti in ordine alfabetico) poi il secondo e così via....

Spero di essere riuscito a spiegarmi.
Fammi sapere se qualcosa non ti è chiaro.

Grazie mille

[simo7784]

Scusa, ma ancora non ho ben capito chi fa da chiave nella tua mappe.
Per come l'hai messa, sembrerebbe quasi che le chiavi dell'hahsmap siano stringhe contenenti il cognome?

mappa.put("Rossi", "Mario");

Ma in questo caso se hai due persone con lo stesso cognome come fai?

EDIT: Se mi posti un pezzo di codice che mi fa un esempio d'inserimento, si fa prima.

[melmar20]

il mio HashMap è dichiarato in questo modo
<EDIT>HashMap<Integer, ContoCorrenteBancario> elencoContiCorrenti;</EDIT>

quindi contiene una serie di Conti Correnti bancari, oggetti della classe ContoCorrenteBancario creata da me. Come key ho degli int, presi dall'attributo numeroConto della classe ContoCorrenteBancario <edit>elencoContiCorrenti.put(nuovoConto.getNumero Conto(), nuovoConto);</edit>

devo ordinare l'HashMap in base all'attributo Cognome della classe ContoCorrenteBancario.

[simo7784]

Ok... Ora ho capito.

Allora le modifiche che farei io...
Classe ContoCorrente

//I TUOI IMPORT SE ESISTONO

public class ContoCorrente implements Comparable {
   //IL TUO CODICE
   
   public String getCognome() {
      return this.cognome;
   }

   public int compareTo(Object altroConto) {
        if(!(altroConto instanceof ContoCorrente)) return 0;
        return this.getCognome().compareTo(altroConto.getCognome());
   }
}

Quando hai bisogno di avere la tua lista ordinata fai

//Ottengo una lista degli oggetti nella HashMap
Collection listaOrdinata = nomeMappa.values();
//Li ordino
Collecions.sort(listaOrdinata);

[melmar20]

Ciao scusami non ho capito cosa fà questa funzione:

public int compareTo(Object altroConto) {
if(!(altroConto instanceof ContoCorrente)) return 0;
return this.getCognome().compareTo(altroConto.getCognome( ));
}

[simo7784]

Serve per confontare due oggetti di tipo omogeneo. Viene usato da Collections.sort per ordinare.

/* Sovrascrivo il metodo compareTo di Comparable.
 * Il metodo confronta due oggetti e restituisce un intero positivo o negativo 
 * a seconda di chi sia il maggiore o il minore.
 */
public int compareTo(Object altroConto) {
   // Se l'argomento non e' un oggetto ContoCorrente, non ordino.
   if(!(altroConto instanceof ContoCorrente)) return 0;
   // In caso contrario ordino in base al campo cognome 
   // essendo una stringa uso il metodo compareTo della classe String, gia' implementato
   return this.getCognome().compareTo(altroConto.getCognome());
}

[andbin]

Originariamente inviato da simo7784

   public int compareTo(Object altroConto) {
        if(!(altroConto instanceof ContoCorrente)) return 0;
        return this.getCognome().compareTo(altroConto.getCognome());
   }

Molto sbagliato!

A parte il fatto che non hai usato i "generics", cosa che invece melmar20 ha intenzione di usare, visto che ha un HashMap<Integer, ContoCorrenteBancario>.

Comunque il grosso errore è quello di ritornare 0 se l'oggetto non è di tipo ContoCorrente. Quando si usa Comparable/Comparator bisogna tenere a mente una cosa molto importante: due oggetti devono essere "mutualmente comparabili".
Di norma (e salvo casi del tutto particolari da codificare in modo specifico) due oggetti di classi diverse NON sono mutualmente comparabili .... come a dire non puoi comparare patate con carote. Di norma un oggetto è mutualmente comparabile solo con un altro oggetto dello stesso tipo.

La documentazione di compareTo() è molto chiara su un punto:

Throws:
ClassCastException - if the specified object's type prevents it from being compared to this object.

Cosa vuol dire? Semplice che se 2 oggetti non sono mutualmente comparabili, deve essere lanciata una eccezione ClassCastException.

Senza l'uso dei generics si dovrebbe scrivere:

public class ContoCorrente implements Comparable {
   // ....

   public int compareTo(Object altroConto) {
        return this.getCognome().compareTo(((ContoCorrente)altroConto).getCognome());
   }
}

Volendo invece usare i generics, si dovrebbe scrivere:

public class ContoCorrente implements Comparable<ContoCorrente> {
   // ....

   public int compareTo(ContoCorrente altroConto) {
        return this.getCognome().compareTo(altroConto.getCognome());
   }
}

In entrambi i casi avviene un cast e se l'oggetto passato non è di tipo ContoCorrente, viene lanciata l'eccezione ClassCastException. Questo è il modo corretto per controllare il tipo dell'oggetto per la comparazione.

[simo7784]

Chiedo venia per l'eccezione non sollevata.
Ho scritto di fretta (infatti manca anche il cast a ContoCorrente nel secondo oggetto).
Usare o meno i generics alla fine non cambia il succo del discorso.
Grazie per la correzione.

[melmar20]

Ciao Ragazzi ,

alla fine ho scritto questa cosa:

public void stampaListaOrdinataConti(){
		/*Dichiaro un Array che conterrà tutti gli indici dell'HashMap*/
		Object [] arrKey=elencoContiCorrenti.keySet().toArray();
		/*Ordino gli indici in base all'ordine alfabetico dell'attributo Cognome dei loro oggetti corrispondentii.*/
		for(int i=0;i<elencoContiCorrenti.size();i++){
			for(int j=i+1;j<elencoContiCorrenti.size();j++){
				if((elencoContiCorrenti.get(arrKey[i]).getCorrentista().getCognome().compareTo(elencoContiCorrenti.get(arrKey[j]).getCorrentista().getCognome())>0)){
					Object appoggio;
					appoggio=arrKey[i];
					arrKey[i]=arrKey[j];
					arrKey[j]=appoggio;
				}
			}
		}
		for(int k=0;k<elencoContiCorrenti.size();k++){
			elencoContiCorrenti.get(arrKey[k]).stampaConto();
		}
		}

Cosa ne pensate?