Come capire come fare algoritmi (su collections framework)?

[HiroshiShiba74]

Ciao, diciamo che la teoria l'ho studiata e qualche piccolo programma l'ho sviluppato ... poi mi trovo esercizi complessi con algoritmi che prevedono l'uso di mappa, liste, ecc. e mi blocco.

Vedendo le loro soluzioni riesco, anche se a fatica, a capirle, però immaginare di mettermi davanti ad un "foglio bianco" e "buttar giù" algoritmi di questa entità...

Avreste qualche suggerimento in merito? Ok, dovrei fare maggiore esperienza, (ri)partire da piccoli programmi, ecc.

[andbin]

Originariamente inviato da HiroshiShiba74
però immaginare di mettermi davanti ad un "foglio bianco" e "buttar giù" algoritmi di questa entità...

Ad esempio? tipo?

[HiroshiShiba74]

Originariamente inviato da andbin
Ad esempio? tipo?

Ad es. (è solo un esempio!):

Scrivere un programma Java in grado di gestire le informazioni relative alle persone sui diversi
voli in arrivo all’aeroporto di Roma. Per ogni volo deve tenere traccia del giorno e della citta’ di partenza, dell’ora di arrivo e di tutte le persone a bordo. La chiave identificativa univoca e’ rappresentata dalla concatenazione della stringa propria del volo con la data nel formato aa-mm-gg. Per ciascuna persona a bordo il programma deve tenere traccia di cognome, nome nazionalita’ e citta’ di residenza. Il programma deve gestire i comandi descritti nel seguito del testo.

LEGGI
Il programma richiedera’ il nome del file, ne leggera’ i dati e li inserira’ nello stato corrente.
ELENCO
stampa l’elenco di tutti i voli presenti in memoria ordinati cronologicamente
NAZIONALITA’
Il programma richiedera’ una nazionalita’ e stampera’ tutte le informazioni (incluso il volo di
arrivo) relative ai passeggeri di quella nazionalita’ presenti nello stato del sistema.

FORMATO DEL FILE DI INPUT
File di testo, un campo per linea. I dati non sono necessariamente ordinati cronologicamente. Il file e’ costituito da una sequenza di record. I record possono essere di tipo VOLO o di tipo
PASSEGGERO.

Un record di tipo VOLO ha il seguente formato:

VOLO
id (stringa)
giorno di partenza (formato aa-mm-gg)
citta’ di partenza (stringa)
ora di arrivo (formato hh:mm)

Un record di tipo PASSEGGERO ha il seguente formato:

PASSEGGERO
cognome
nome
nazionalita’
citta’ di residenza
volo di arrivo (chiave univoca ID+data)

[andbin]

Sì, è un po' "elaborato" e richiede di gestire svariate cose ma nulla di trascendentale.

Innanzitutto è chiaro che ci sono N voli, ognuno con M passeggeri. A parte gli aspetti di lettura del file e gestione dei comandi, la questione "chiave" da valutare bene è come legare insieme (intendo a livello di oggetti) i passeggeri ai voli.

Il fatto che la chiave univoca sia ID volo + data, ok. C'è solo una cosa che non mi quadra (per come è scritto il testo). La data dovrebbe essere, concettualmente, quella di arrivo ma per Volo è indicata solo la data di partenza.

Comunque il punto è proprio come legare passeggeri e voli. Non è precisato se nel file i passeggeri dovranno essere sempre dopo il loro volo. Se non è così (e lo suppongo), sarebbe critico legare i passeggeri ai voli mentre leggi il file.

Ad ogni modo, le possibilità sono almeno 2:
a) tenere separati gli oggetti Volo e Passeggero. Cioè non cercare di far sì che Volo abbia una collezione di oggetti Passeggero e nemmeno che Passeggero abbia il riferimento al Volo.

b) appena finito di leggere il file, cerchi di legare insieme tra di loro i voli e i passeggeri. Ovviamente le classi devono essere predisposte in tal senso.

Adesso è tardi, se hai dubbi specifici chiedi pure.

[HiroshiShiba74]

Sempre così gentile, a domani!

Originariamente inviato da andbin

Adesso è tardi, se hai dubbi specifici chiedi pure.

[alemagno]

brr

[HiroshiShiba74]

Ciao! E' solo un work in progress , ma vorrei comunque conoscere (al più presto! ) il tuo/vostro parere

In una cartella chiamata aeroportomio creo tre file:

aeroportomio.java
passeggeromio.java
volomio.java


==============================================
Nel file volomio.java scrivo:

package aeroportomio;

public class Volomio
{
   String id;
   String giorno;        // formato aa-mm-gg
   String cittaPartenza;
   String oraArrivo;     // formato hh:mm

}


==============================================
Nel file passeggeromio.java scrivo:

package aeroportomio;

public class Passeggeromio
{
   String cognome;
   String nome;
   String nazionalita;
   String cittaResidenza;
   // volo di arrivo (chiave univoca ID + data)


}


==============================================
Nel file aeroportomio.java scrivo:

package aeroportomio;

import java.util.*;
import java.io.*;

public class Aeroportomio;
{
   List<Passeggeromio> tutteIPasseggeri;
   Map<Volomio> tuttiIVoli;

   public Aeroportomio()
   {
      tuttiIPasseggeri = new LinkedList<Passeggeromio> ();
      tuttiIVoli = new HashMap<Volomio> ();

      public static void main(String[] args)
      {
         (new Aeroportomio()).start();  // esegui il menu
      }

      public void start()
      {
         Scanner inserimento = new Scanner(System.in);
         String comando;
       
         while (true)
         {
	    System.out.println("                                   ");
            System.out.println("                                   ");
            System.out.println("***********************************");
            System.out.println("*       Gestione Aeroporto        *");
            System.out.println("***********************************");
            System.out.print(  [Leggi/Elenco/Nazionalita/Esci] > ");
           
            comando = inserimento.nextLine();
	            
	    if (comando.equalsIgnoreCase("Esci")) 
	    {
	       System.out.println("E' stato un piacere. Grazie e arrivederci alla prossima!");
               break;
	    } 
	            
            else if (comando.equalsIgnoreCase("Leggi")) 
	    {
	       leggi();
            } 
	            
	    else if (comando.equalsIgnoreCase("Elenco")) 
            {
	       elenco();
	    } 
	            
	    else if (comando.equalsIgnoreCase("Nazionalita")) 
	    {
	       nazionalita();
	    } 
	            
	    else 
	    {
	       System.out.println("Comando non valido, riprova perfavore");
            }
         }  // chiudo il while
      }  // chiudo start
   
   
      private void leggi()   // Legge i dati da un file che viene indicato dall'utente
      {
         System.out.println("Nome del file (comprensivo di estensione)? > ");
         String nomeFile = scanner.nextLine(); // a nomeFile si assegna il nome del file che l'utente indica
      
         try 
         {
            Scanner file = new Scanner(new FileReader(nomeFile));

            while (file.hasNextLine()) // finchè il file non è vuoto
            {
               primaRiga = rigaSuccessiva = file.nextLine();
               
               if primaRiga equals ("VOLO")
               {
                  while (rigaSuccessiva equals "VOLO" or "PASSEGGERO")
                  {
                     volomio.id() = rigaSuccessiva; 
                     volomio.giornoPartenza() = rigaSuccessiva;
                     volomio.cittaPartenza() = rigaSuccessiva;
                     volomio.oraArrivo() = rigaSuccessiva;
                  } 
               }
               else if primaRiga equals ("PASSEGGERO")
               {
                   while (rigaSuccessiva equals "VOLO" or "PASSEGGERO")
                  {
                     passeggeromio.cognome() = rigaSuccessiva; 
                     passeggeromio.nome() = rigaSuccessiva;
                     passeggeromio.nazionalita() = rigaSuccessiva;
                     passeggeromio.cittaResidenza() = rigaSuccessiva;
                     // passeggeromio.voloArrivo()
               }
               else 
               {
                  System.out.println("Mi dispiace, file di input non valido");
                  break;   
               }  
	  } // chiudo while
       	        
          catch (FileNotFoundException fnfe) 
          {
             System.out.println("Mi dispiace, non trovo un file con quel nome");
          }
      } // chiudo leggi


      private void elenco() 
   {
       System.out.println("Nome del file (comprensivo di estensione)? > ");
       String nomeFile = scanner.nextLine(); // a nomeFile si assegna il nome del file che l'utente indica
      
       try 
       {
           Scanner file = new Scanner(new FileReader(nomeFile));


   }

[schumy2000]

Spero sia solo uno pseudocodice:

primaRiga = rigaSuccessiva = file.nextLine();

Non sono state dichiarate le due stringhe.

 if primaRiga equals ("VOLO")

l'if sempre tra parentesi

 volomio.id()  
 volomio.giornoPartenza() 
 volomio.cittaPartenza() 
 volomio.oraArrivo()

What?
Non hai dichiarato nè istanziato volomio e passeggeromio.
Inoltre nella programmazione ad oggetti non è consigliabile chiamare l'attributo (a parte che non si richiama così), ma è buona norma creare dei metodi getter e setter nella rispettive classi per esporre e/o valorizzare gli attributi.
Allo stesso tempo nella classe dichiarare tutti gli attributi come:

private String id;

e cosi via gli altri.

public class Aeroportomio;
{
   List<Passeggeromio> tutteIPasseggeri;
   Map<Volomio> tuttiIVoli;

   public Aeroportomio()
   {
      tuttiIPasseggeri = new LinkedList<Passeggeromio> ();
      tuttiIVoli = new HashMap<Volomio> ();

perché dichiari e istanzi le collection se alla fine non li usi?

 public Aeroportomio()
   {
      tuttiIPasseggeri = new LinkedList<Passeggeromio> ();
      tuttiIVoli = new HashMap<Volomio> ();
   }

alla fine di questo metodo va una parentesi altrimenti il programma di va in palla.


Cmq a livello di idea dovrebbe essere una cosa del genere se vuoi disgiungere le due entità.

Ciao.

[HiroshiShiba74]

Originariamente inviato da schumy2000
Spero sia solo uno pseudocodice:

Sì, più o meno

primaRiga = rigaSuccessiva = file.nextLine();

Non sono state dichiarate le due stringhe.

Dovrei fare, considerandole stringhe costituite da ciò che viene riportato nella riga del file di input:

String primaRiga, rigaSuccessiva;

o dovrei fare (anche):

String primaRiga, rigaSuccessiva = new (file.nextLine());

public class Aeroportomio;
{
   List<Passeggeromio> tutteIPasseggeri;
   Map<Volomio> tuttiIVoli;

   public Aeroportomio()
   {
      tuttiIPasseggeri = new LinkedList<Passeggeromio> ();
      tuttiIVoli = new HashMap<Volomio> ();

perché dichiari e istanzi le collection se alla fine non li usi?

Non ho avuto ancora tempo per (capire come) farlo

Cmq a livello di idea dovrebbe essere una cosa del genere se vuoi disgiungere le due entità.
Ciao.

Ti ringrazio molto per il tuo contributo. La soluzione, o meglio una soluzione, quella "ufficiale", la conosco anche se non l'ho capita del tutto. Volevo svolgere l'esercizio da zero, anche perchè altrimenti non imparo mai e poi perchè, come dice il docente, non è l'unica soluzione possibile.

[HiroshiShiba74]

Volo.java

package aeroporto;

import java.util.*;

public class Volo
implements Comparable
{
	String key;
	String id; 
	String part;   
	String citta;                                  
	String arr; 

	List<Passeggero> list = new LinkedList<Passeggero>();
 
	public void popolaCampi(Scanner sc)
	{
		id = sc.nextLine();
		part = sc.nextLine();
		citta = sc.nextLine();
		arr = sc.nextLine();
		key = id.concat(part);  
     	}

	public void addPasseggero(Passeggero p)
	{
		if(!p.idVolo.equals(key))
		{
		   throw new IllegalArgumentException(p.toString() + " non vola con " + toString());
		}
		list.add(p);
	}

	public int compareTo(Object o)
	{
		assert o instanceof Volo;
		Volo v = (Volo)o;
		return part.compareTo(v.part);
	}

	public String toString()
	{
		return "<id: " + id + "; giorn part: " + part + "; origine: " + citta + "; ora arrivo: " + arr + ">";
	}
}

Passeggero.java

package aeroporto;

public class Passeggero
{
	String cognome; 
	String nome; 
	String nazione; 
	String residenza; 
	String idVolo; 


	public void popolaCampi(Java.util.Scanner sc)
	{
		cognome = sc.nextLine();
		nome = sc.nextLine();
		nazione = sc.nextLine();
		residenza = sc.nextLine();
		idVolo = sc.nextLine();
	}

	public String toString()
	{
		return "<Cognome: " + cognome + "; Nome: " + nome + "; Nazionalita: " + nazione + "; Residenza: " + residenza + "; id volo: " + idVolo + ">";
	}
}

Infine aeroporto.java

package aeroporto;

import java.util.*;
import java.io.*;

public class Aeroporto
{
	Map<String, Volo> voli = new HashMap<String, Volo>();
	Map<String, List<Passeggero>> nazionalita = new HashMap<String, List<Passeggero>>();
	List<Volo> elenco = new LinkedList<Volo>();

	public static void main(String[] argv)
	{
		(new Aeroporto()).exec(argv);
	}

	void exec(String[] argv)
	{
		Scanner stdin = new Scanner(System.in);

		while(true)
		{
			System.out.print("cmd? Leggi/Elenco/Nazionalita/Exit > ");    //r
			String cmd = stdin.nextLine();
			if(cmd == null || cmd.equals("") || cmd.equalsIgnoreCase("exit"))
			{
				break;
			}
			else if(cmd.equalsIgnoreCase("leggi"))
			{
				leggi(stdin);
			}
			else if(cmd.equalsIgnoreCase("elenco"))
			{
				elenco(stdin);
			}
			else if(cmd.equalsIgnoreCase("nazionalita"))
			{
				nazionalita(stdin);
			}
			else
			{
				System.out.println("Comando <" + cmd + "> non riconosciuto");
			}
		}
	}

	void nazionalita(Scanner sc)
	{
		System.out.print("Nazionalita? > ");
		String n = sc.nextLine();
		List<Passeggero> l = nazionalita.get(n);
		System.out.println(String.valueOf(l));
	}

	void elenco(Scanner sc)
	{
		Collections.sort(elenco);
		System.out.println(elenco);
	}

	void leggi(Scanner sc)
	{
		System.out.print("Nome file? > ");
		String nome = sc.nextLine();
		Scanner file = null;
		try
		{
			file = new Scanner(new FileReader(nome));
			while(file.hasNextLine())
			{
				String tipo = sc.nextLine();
				if(tipo.equals("VOLO"))
				{
					Volo v = new Volo();
					v.popolaCampi(file);
					voli.put(v.key, v);

					elenco.add(v);
				}
				else if(tipo.equals("PASSEGGERO"))
				{
					Passeggero p = new Passeggero();
					Volo v = voli.get(p.idVolo);
					v.addPasseggero(p);

					List<Passeggero> l = nazionalita.get(p.nazione);
					if(l == null)
					{
						l = new LinkedList<Passeggero>();
						nazionalita.put(p.nazione, l);
					}
					l.add(p);
				}
				else
				{
					System.out.println("Record tipo <" + tipo + "> non riconosciuto");
					continue;
				}
			}
			file.close();
		}
		catch(IOException ioe)
		{
			ioe.printStackTrace();
		}
	}
}

E' possibile secondo voi migliorare questo codice?
Quale potrebbe essere una soluzione alternativa? Magari al posto delle HashMap utilizzare delle LinkedHashMap, ecc.

Fatemi sapere, grazie!