[Java] Stampa ordinata TreeMap

[v1sc3rr4k]

L'esercizio mi dice di implementare un programma di gestione di un comune. In cui ho un file di testo con i dati dei residenti e uno per gli immobili.
La gestione richiede che devo stampare in ordine alfabetico i cittadini elencando per ogni cittadino il numero totale di immobili e i metri quadri totali delle propietà quindi per ogni cittadino devo avere una stampa del tipo:
Nome Cognome ImmobiliPosseduti MetriQuadriTotali

Per ogni residente ho 4 valori :

1) Nome
2) Cognome
3) Codice fiscale
4) Data di nascita

Per ogni immobile ho 4 valori:

1) Indirizzo
2) Locali
3) Metri quadri
4) Codice fiscale del propietario

Vi posto le 3 classi Cittadino, Immobile e Gestione

Cittadino.java
import java.io.PrintStream;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Scanner;


public class Cittadino {

public Cittadino (String nome, String cognome, String codiceFiscale, String dataNascita)
{
this.nome=nome;
this.cognome=cognome;
this.codiceFiscale=codiceFiscale;
this.dataNascita=dataNascita;
this.immobili=new LinkedList<Immobile>();
}

public static Cittadino read(Scanner s)
{
if(!s.hasNext()) return null;
String nome = s.next();
String cognome = s.next();
String codiceFiscale = s.next();
String dataNascita = s.next();

return new Cittadino(nome, cognome, codiceFiscale, dataNascita);


}

public String getNome()
{
return nome;
}

public String getCognome()
{
return cognome;
}


public String getCodiceFiscale()
{
return codiceFiscale;
}

public String getDataNascita()
{
return dataNascita;
}

public String toString()
{
return getNome() + " " + getCognome();
}

public void addImmobile(Immobile i)
{
immobili.add(i);
}

public Iterator<Immobile> iterator()
{
return immobili.iterator();
}

public void print()
{
System.out.println(toString());
}

public void print(PrintStream p)
{
p.println(toString());
}

private String nome , cognome, codiceFiscale, dataNascita;
private LinkedList<Immobile> immobili;
}


Immobile.java

import java.util.Scanner;


public class Immobile {

public Immobile (String indirizzo, int interno, int metriQuadri, String codiceFiscale)
{
this.indirizzo= indirizzo;
this.interno= interno;
this.metriQuadri=metriQuadri;
this.codiceFiscale=codiceFiscale;
propietario= null;
}

public static Immobile read(Scanner s)
{
if(!s.hasNext()) return null;
String indirizzo=s.nextLine();
int interno=s.nextInt();
int metriQuadri=s.nextInt();
String codiceFiscale=s.next();
s.nextLine();

return new Immobile(indirizzo, interno, metriQuadri, codiceFiscale);
}

public String getIndirizzo()
{
return indirizzo;
}

public String getCodiceFiscale()
{
return codiceFiscale;
}

public int getInterno()
{
return interno;
}

public int getMetriQuadri()
{
return metriQuadri;
}

public Cittadino getPropietario()
{
return propietario;
}

public void setPropietario (Cittadino c)
{
propietario=c;
}

private String indirizzo, codiceFiscale;
private int interno, metriQuadri;
private Cittadino propietario;
}


Gestione.java
import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;



public class Gestione {

public Gestione (String elencoCittadini, String elencoImmobili) throws FileNotFoundException

{
Scanner s1=new Scanner(new File(elencoCittadini));
Scanner s2=new Scanner(new File(elencoImmobili));


Cittadino c=Cittadino.read(s1);

while(c!=null)
{
cittadini.put(c.getCodiceFiscale(), c);
c=Cittadino.read(s1);
}

Immobile i= Immobile.read(s2);

while (i!=null)
{
immobili.add(i);
i.setPropietario(cittadini.get(i.getCodiceFiscale())); //la chiave è codice fiscale variabile d'istanza dell'immobile

i=Immobile.read(s2);
}


s1.close();
s2.close();
}







private ArrayList<Immobile> immobili = new ArrayList<Immobile>();
private Map<String , Cittadino> cittadini = new TreeMap<String, Cittadino>();
}



Scusate la mancanza di commenti ma sto facendo molti esercizi velocemente.
Comunque a grandi linee nella prima classe la LinkedList è creata perchè così ogni cittadino avrà come variabile d'istanza la lista concatenata delle sue propietà. Nella seconda classe Immobile.java nel costruttore il propietario è settato a null per poi essere impostato dopo con un metodo specifico. Nella classe Gestione.java il costruttore riceve come parametri i due file elenco dei cittadini e degli immobili per poi riempire l'ArrayList contenente tutti gli immobili e la TreeMap avente come chiave il codiceFiscale e come valore il cittadino. La scelta del codiceFiscale come chiave è stata fatta perchè valore in comune sia con gli immobili che con i cittadini. Ora il problema è che la stampa la devo fare in ordine del cognome. Ho provato vari modi ma non ho nuove idee.

Nella classe gestione manca solo la parte riguardante l'ordinamento, volevo chiedere aiuto a voi per la soluzione di questo metodo. Inoltre se notate errori o consigli riguardo il codice vi prego di evidenziarmeli. Sono uno studente alle prime armi con la programmazione object oriented mediante java.
Grazie in anticipo :)

[banryu79]

Stampare la lista di valori:

Nome Cognome ImmobiliPosseduti MetriQuadriTotali

in ordine alfabetico rispetto al cognome dei cittadini significa avere una lista ordinata per cognome dei cittadini, su cui procedere iterando ogni cittadino per estrarre da esso il CodiceFiscale, valore che usiamo come chiave per contare tutti gli immobili associati e sommare di essi il valore metri quadri, per trovare il totole.

Quindi come collezioni di dati io partirei memorizzando tutti i cittadini in una List (qualsiasi implementazione va bene) e non in una Map.
Scelgo la List perchè la classe Cittadino la definisco facendole implementare l'interfaccia java.util.Comparable (definendo il metodo compareTo basando i confronti sul cognome del cittadino, usando un java.text.Collator) in modo da poterla ordinare facilmente, passando la List di cittadini, dopo averla popolata da lettura del file di input, al metodo sort() della classe java.util.Collections.

Sono invece gli immobili, che li memorizzerei in una Map la cui chiave è il CodiceFiscaleProprietario e il valore è una List di Immobili, quindi definendola più o meno così:

// da qualche parte, nel codice del Gestore:
Map<String, List<Immobile>> mapImmobili = ...

Che puoi implementare come preferisci, ad esempio:

// implementata con una hash map
... = new HashMap<String, List<Immobile>>();

// implementata con una tree map
... = new TreeMap<String, List<Immobile>>();


A questo punto stampare la lista richiesta diventa una questione di questo tipo:

1) itero la List (già ordinata grazie al Comparable e a Collections.sort) di cittadini recuperando un Cittadino alla volta;
2) recupero il CodiceFiscale del Cittadino;
3) cerco nella Map la List<Immobile> associata alla chiave CodiceFiscale che ho appena recuperato;
4) calcolo il numero di Immobili nella lista (metodo size() della List);
5) calcolo i metri quadrato totali (potresti creare un metodo che preso in ingresso una List<Immobile> calcola il totale e lo restituisce al chiamante);
6) stampo tutte le stringhe.