Indice

1 Implementazione completa di uno scenario ospedaliero
- 1.1 Modellazione dello Scenario
- 1.2 Implementazione della coda
2 Esercizi
3 Classi astratte e metodi astratti

Implementazione completa di uno scenario ospedaliero

Modellazione dello Scenario

Modellazione iniziale delle classi utili all'implementazione delo scenario richiesto.

Classe Persona: classe base da cui far derivare le classi Medico e Paziente.

```
public class Persona {
```
```
	protected String nome;
```
```
	protected String cognome;
```
```
	protected String CF;
```
```
 
```

	public Persona(String N, String C, String cf)

```
	{
```
```
		nome = N;
```
```
		cognome = C;
```
```
		CF = cf;
```
```
	}
```
```
}
```

Classe Medico: derivata dalla classe Persona, definisce un medico in base alla propria specializzazione.

```
public class Medico extends Persona {
```
```
 
```
```
	private String specializzazione;
```
```
 
```

	public Medico(String N, String C, String cf, String spec) {

```
		super(N, C, cf);
```
```
		specializzazione = spec;	
```
```
	}
```
```
 
```
```
	public String getInfo()
```
```
	{
```

		String info = nome + "\t" + cognome + "\t" + CF + "\t" + specializzazione;

```
		return info;
```
```
	}
```
```
 
```
```
}
```

Classe Paziente: derivata dalla classe Persona, definisce un paziente in base ad una diagnosi.

```
public class Paziente extends Persona {
```
```
 
```
```
	private String diagnosi;
```
```
 
```

	public Paziente(String N, String C, String cf, String D) {

```
		super(N, C, cf);
```
```
		diagnosi = D;
```
```
	}
```
```
 
```
```
	public String getInfo()
```
```
	{
```

		String info = nome + "\t" + cognome + "\t" + CF + "\t" + diagnosi;

```
		return info;
```
```
	}
```
```
 
```
```
}
```

Classe Ospedale: deve contenere tutti i medici e tutti i pazienti afferenti ad ogni ospedale. SOno state implementate le funzioni di aggiunta medici e pazienti, oltre alle funzioni di stampa delle informazioni.

```
import java.util.ArrayList;
```
```
import java.util.LinkedList;
```
```
 
```
```
public class Ospedale {
```
```
	private String nomeOspedale;
```
```
 
```
```
	private ArrayList<Medico> listaMedici;
```

	private LinkedList<Paziente> listaPazienti;

```
 
```
```
	public Ospedale(String N)
```
```
	{
```
```
		nomeOspedale = N;
```

		listaMedici = new ArrayList<Medico>();

		listaPazienti = new LinkedList<Paziente>();

```
	}
```
```
 
```
```
	public void aggiungiMedici(Medico M)
```
```
	{
```
```
		listaMedici.add(M);
```

		System.out.println("Medico Aggiunto");

```
	}
```
```
 
```

	public void aggiungiMedici(ArrayList<Medico> LM)

```
	{
```
```
		listaMedici.addAll(LM);
```

		System.out.println("Medici Aggiunti");

```
	}
```
```
 
```

	public void aggiungiPazienti(Paziente P)

```
	{
```
```
		listaPazienti.add(P);
```

		System.out.println("Paziente Aggiunto");

```
	}
```
```
 
```

	public void aggiungiPazienti(ArrayList<Paziente> LP)

```
	{
```
```
		listaPazienti.addAll(LP);
```

		System.out.println("Pazienti Aggiunti");

```
	}
```
```
 
```
```
	public void stampaMedici()
```
```
	{
```
```
		System.out.println("Lista Medici:");
```

		for (int i = 0; i < listaMedici.size(); i++)

```
		{
```

			System.out.println((i+1) + ": " + listaMedici.get(i).getInfo());

```
		}
```
```
	}
```
```
 
```
```
	public void stampaPazienti()
```
```
	{
```

		System.out.println("Lista Pazienti:");

		for (int i = 0; i < listaPazienti.size(); i++)

```
		{
```

			System.out.println((i+1) + ": " + listaPazienti.get(i).getInfo());

```
		}
```
```
	}
```
```
}
```

Classe Principale: classe che contiene il metodo main.

```
import java.util.ArrayList;
```
```
 
```
```
public class Principale {
```
```
 
```

	public static void main(String[] args) {

```
 
```

		Ospedale o = new Ospedale("Policlinico");

```
 
```

		Medico m1 = new Medico("M_Nome1", "M_Cognome1", "M_Codice1", "Chirurgia");

		Medico m2 = new Medico("M_Nome2", "M_Cognome2", "M_Codice2", "Radiologia");

		Medico m3 = new Medico("M_Nome3", "M_Cognome3", "M_Codice3", "Cardiologia");

```
 
```

		ArrayList<Medico> lm = new ArrayList<Medico>();

```
		lm.add(m1);
```
```
		lm.add(m3);
```
```
		o.aggiungiMedici(m2);
```
```
		o.aggiungiMedici(lm);
```
```
 
```

		Paziente p1 = new Paziente("P_Nome1", "P_Cognome1", "P_Codice1", "Frattura");

		Paziente p2 = new Paziente("P_Nome2", "P_Cognome2", "P_Codice2", "Tumore");

		Paziente p3 = new Paziente("P_Nome3", "P_Cognome3", "P_Codice3", "Infarto");

```
 
```

		ArrayList<Paziente> lp = new ArrayList<Paziente>();

```
		lp.add(p1);
```
```
		lp.add(p2);
```
```
		o.aggiungiPazienti(p3);
```
```
		o.aggiungiPazienti(lp);
```
```
 
```
```
		System.out.println();
```

		System.out.println("////////////////////////////////////////////////");

```
		o.stampaMedici();
```
```
		System.out.println();
```
```
		o.stampaPazienti();
```
```
 
```
```
	}
```
```
}
```

Implementazione della coda

Implementazione della coda delle prenotazioni e update delle classi esistenti

Classe Persona: classe base da cui far derivare le classi Medico e Paziente.

```
public class Persona {
```
```
	protected String nome;
```
```
	protected String cognome;
```
```
	protected String CF;
```
```
 
```

	public Persona(String N, String C, String cf)

```
	{
```
```
		nome = N;
```
```
		cognome = C;
```
```
		CF = cf;
```
```
	}
```
```
 
```
```
	public String getNome()
```
```
	{
```
```
		return nome;
```
```
	}
```
```
 
```
```
	public String getCognome()
```
```
	{
```
```
		return cognome;
```
```
	}
```
```
 
```
```
	public String getCF()
```
```
	{
```
```
		return CF;
```
```
	}
```
```
}
```

Classe Medico: derivata dalla classe Persona, definisce un medico in base alla propria specializzazione. Nella classe è stata aggionta la coda delle prenotazioni.

```
public class Medico extends Persona {
```
```
 
```
```
	private String specializzazione;
```
```
 
```

	private Prenotazione[] codaPrenotazioni;

```
 
```

	// Variabili per la gestione della coda

```
	private int head;
```
```
	private int tail;
```
```
	private int length;
```
```
	private int size;
```
```
 
```

	public Medico(String N, String C, String cf,

```
			String spec, int DimCoda) {
```
```
		super(N, C, cf);
```
```
		specializzazione = spec;	
```
```
 
```
```
		length = DimCoda;
```
```
		head = 0;
```
```
		tail = 0;
```
```
		size = 0;
```
```
 
```

		codaPrenotazioni = new Prenotazione[length];

```
	}
```
```
 
```
```
	public String getInfo()
```
```
	{
```

		String info = nome + "\t" + cognome + "\t" + CF + "\t" + specializzazione;

```
		return info;
```
```
	}
```
```
 
```
```
	public boolean isAvailable()
```
```
	{
```
```
		if (size == length)
```
```
			return false;
```
```
		return true;
```
```
	}
```
```
 
```
```
	public int utentiInCoda()
```
```
	{
```
```
		return size;
```
```
	}
```
```
 
```
```
 
```
```
	public void stampaStatoCoda()
```
```
	{
```
```
		int i = 0;
```
```
		if (size == 0)
```

			System.out.println("Nessuna prenotazione");

```
		else
```
```
		{
```

			System.out.println("Prenotazioni in coda:");

```
			for (i = 0; i < size; i++) {
```

				System.out.println((i+1) + "\t" + codaPrenotazioni[(head + i) % length].stampaInfoPrenotazione());

```
			}
```
```
		}
```
```
		System.out.println();
```
```
	}
```
```
 
```

	public void accettaPazienteInCoda(Prenotazione P)

```
	{
```
```
		codaPrenotazioni[tail] = P;
```
```
		tail = (tail + 1) % length;
```
```
		size++;
```
```
	}
```
```
 
```

	public void curaProssimoPaziente(Ospedale o)

```
	{
```
```
		if (size == 0)
```
```
		{
```

			System.out.println("Nessuna Prenotazione in coda");

```
		}
```
```
		else {
```

			Prenotazione temp = codaPrenotazioni[head];

```
			head = (head + 1) % length;
```
```
			size--;
```
```
 
```
```
			eseguiVisita(temp, o);
```
```
		}
```
```
	}
```
```
 
```

	private void eseguiVisita(Prenotazione p, Ospedale o)

```
	{
```

		Visita v = new Visita(this.CF, p.getPaziente().getDiagnosi(), p.getTrattamento(), o.getNome());

```
		p.getPaziente().aggiungiVisita(v);
```
```
	}
```
```
}
```

Classe Paziente: derivata dalla classe Persona, definisce un paziente in base ad una diagnosi. La classe Paziente contiene una lista che mantiene tutte le visite effettuate da ciascun paziente.

```
import java.util.LinkedList;
```
```
 
```
```
public class Paziente extends Persona {
```
```
 
```
```
	private String diagnosi;
```

	private LinkedList<Visita> cartellaClinica;

```
 
```

	public Paziente(String N, String C, String cf, String D) {

```
		super(N, C, cf);
```
```
		diagnosi = D;
```

		cartellaClinica = new LinkedList<Visita>();

```
	}
```
```
 
```
```
	public String getInfo()
```
```
	{
```

		String info = nome + "\t" + cognome + "\t" + CF + "\t" + diagnosi;

```
		return info;
```
```
	}
```
```
 
```
```
	public String getDiagnosi()
```
```
	{
```
```
		return diagnosi;
```
```
	}
```
```
 
```
```
	public void aggiungiVisita(Visita v)
```
```
	{
```
```
		cartellaClinica.add(v);
```
```
	}
```
```
 
```
```
	public void stampaCartellaClinica() 
```
```
	{
```

		System.out.println("Paziente:\t" + nome + "\t" + cognome);

```
		if (cartellaClinica.size() == 0)
```
```
		{
```

			System.out.println("Nessuna visita effettuata finora");

```
		}
```
```
		else
```
```
		{
```

			for (int i = 0; i < cartellaClinica.size(); i++)

```
			{
```

				cartellaClinica.get(i).stampaInformazioniVisita();

```
			}
```
```
		}
```
```
	}
```
```
}
```

Classe Ospedale: deve contenere tutti i medici e tutti i pazienti afferenti ad ogni ospedale. Sono state implementate le funzioni di aggiunta medici e pazienti, oltre alle funzioni di stampa delle informazioni. L'ospedale assegna la prenotazione al medico che contiene meno prenotazioni in coda.

```
import java.util.ArrayList;
```
```
import java.util.LinkedList;
```
```
 
```
```
public class Ospedale {
```
```
	private String nomeOspedale;
```
```
 
```
```
	private ArrayList<Medico> listaMedici;
```

	private LinkedList<Paziente> listaPazienti;

```
 
```
```
 
```
```
	public Ospedale(String N)
```
```
	{
```
```
		nomeOspedale = N;
```

		listaMedici = new ArrayList<Medico>();

		listaPazienti = new LinkedList<Paziente>();

```
	}
```
```
 
```
```
	public String getNome()
```
```
	{
```
```
		return nomeOspedale;
```
```
	}
```
```
 
```
```
	public void aggiungiMedici(Medico M)
```
```
	{
```
```
		listaMedici.add(M);
```

		System.out.println("Medico Aggiunto");

```
	}
```
```
 
```

	public void aggiungiMedici(ArrayList<Medico> LM)

```
	{
```
```
		listaMedici.addAll(LM);
```

		System.out.println("Medici Aggiunti");

```
	}
```
```
 
```

	public void aggiungiPazienti(Paziente P)

```
	{
```
```
		listaPazienti.add(P);
```

		System.out.println("Paziente Aggiunto");

```
	}
```
```
 
```

	public void aggiungiPazienti(ArrayList<Paziente> LP)

```
	{
```
```
		listaPazienti.addAll(LP);
```

		System.out.println("Pazienti Aggiunti");

```
	}
```
```
 
```
```
	public void stampaMedici()
```
```
	{
```
```
		System.out.println("Lista Medici:");
```

		for (int i = 0; i < listaMedici.size(); i++)

```
		{
```

			System.out.println((i+1) + ": " + listaMedici.get(i).getInfo());

```
		}
```
```
	}
```
```
 
```
```
	public void stampaPazienti()
```
```
	{
```

		System.out.println("Lista Pazienti:");

		for (int i = 0; i < listaPazienti.size(); i++)

```
		{
```

			System.out.println((i+1) + ": " + listaPazienti.get(i).getInfo());

```
		}
```
```
	}
```
```
 
```

	public void assegnaPrenotazioneMedico(Prenotazione P)

```
	{
```
```
		int idx = trovaMedicoLibero();
```
```
		if (idx > -1)
```

			listaMedici.get(idx).accettaPazienteInCoda(P);

```
		else
```

			System.out.println("Nessun medico disponibile ad accettare la prenotazione " + P.stampaInfoPrenotazione());

```
	}
```
```
 
```
```
	private int trovaMedicoLibero () 
```
```
	{
```

		// Restituisce l'indice della lista dei medici con il medico con meno utenti in coda

```
		int idx_min = -1;
```
```
		if (listaMedici.size() != 0)
```
```
		{
```

			// Devo trovare il primo medico disponibile

			for(int i = 0; i < listaMedici.size(); i++)

```
			{
```

				if(listaMedici.get(i).isAvailable())

```
				{
```
```
					idx_min = i;
```
```
					break;
```
```
				}
```
```
			}
```
```
		}
```
```
		if (idx_min > -1)
```
```
		{
```

			for (int i = idx_min + 1; i < listaMedici.size(); i++)

```
			{
```

				if (listaMedici.get(i).isAvailable() &&  (listaMedici.get(i).utentiInCoda() < listaMedici.get(idx_min).utentiInCoda()))

```
				{
```
```
					idx_min = i;
```
```
				}
```
```
			}
```
```
 
```
```
		}
```
```
		return idx_min;
```
```
	}
```
```
 
```
```
	public void stampaStatoMedici()
```
```
	{
```

		for (int i = 0; i < listaMedici.size(); i++)

```
		{
```

			System.out.println("Medico: " + listaMedici.get(i).getCognome());

			listaMedici.get(i).stampaStatoCoda();

```
		}
```
```
	}
```
```
 
```
```
}
```

Classe Prenotazione: modella la prenotazione di un paziente

```
public class Prenotazione {
```
```
 
```
```
	private Paziente p;
```
```
	private String trattamento;
```
```
 
```

	public Prenotazione(Paziente P, String T)

```
	{
```
```
		p = P;
```
```
		trattamento = T;
```
```
	}
```
```
 
```
```
	public String stampaInfoPrenotazione()
```
```
	{
```

		String info = "Paziente:\t" + p.getCF() + "\tTrattamento: " + trattamento;

```
		return info;
```
```
	}
```
```
 
```
```
	public Paziente getPaziente() 
```
```
	{
```
```
		return p;
```
```
	}
```
```
 
```
```
	public String getTrattamento() 
```
```
	{
```
```
		return trattamento;
```
```
	}
```
```
}
```

Classe Visita: Modella la visita di un medico che esegue un trattamento ad un paziente.

```
public class Visita {
```
```
	private String medico;
```
```
	private String diagnosi;
```
```
	private String trattamento;
```
```
	private String ospedale;
```
```
 
```

	public Visita(String M, String D, String T, String O)

```
	{	
```
```
		medico = M;
```
```
		diagnosi = D;
```
```
		trattamento = T;
```
```
		ospedale = O;
```
```
	}
```
```
 
```

	public void stampaInformazioniVisita()

```
	{
```

		System.out.println("Diagnosi:  " + diagnosi	+ " Visita effettuata dal medico: " + medico + " che ha eseguito il seguente trattamento: " + trattamento +

				" presso il seguente ospedale: " + ospedale);

```
	}
```
```
}
```

Classe Principale: classe che contiene il metodo main.

```
import java.util.ArrayList;
```
```
 
```
```
public class Principale {
```
```
 
```

	public static void main(String[] args) {

```
 
```

		Ospedale o = new Ospedale("Policlinico");

```
 
```

		Medico m1 = new Medico("M_Nome1", "M_Cognome1", "M_Codice1", "Chirurgia", 3);

		Medico m2 = new Medico("M_Nome2", "M_Cognome2", "M_Codice2", "Radiologia", 3);

		Medico m3 = new Medico("M_Nome3", "M_Cognome3", "M_Codice3", "Cardiologia", 5);

```
 
```

		ArrayList<Medico> lm = new ArrayList<Medico>();

```
		lm.add(m1);
```
```
		lm.add(m3);
```
```
		o.aggiungiMedici(m2);
```
```
		o.aggiungiMedici(lm);
```
```
 
```

		Paziente p1 = new Paziente("P_Nome1", "P_Cognome1", "P_Codice1", "Frattura");

		Paziente p2 = new Paziente("P_Nome2", "P_Cognome2", "P_Codice2", "Tumore");

		Paziente p3 = new Paziente("P_Nome3", "P_Cognome3", "P_Codice3", "Infarto");

```
 
```

		ArrayList<Paziente> lp = new ArrayList<Paziente>();

```
		lp.add(p1);
```
```
		lp.add(p2);
```
```
		o.aggiungiPazienti(p3);
```
```
		o.aggiungiPazienti(lp);
```
```
 
```
```
		System.out.println();
```

		System.out.println("////////////////////////////////////////////////");

```
		o.stampaMedici();
```
```
		System.out.println();
```
```
		o.stampaPazienti();
```
```
 
```

		Prenotazione pren1 = new Prenotazione(p1, "Trattamento1");

		Prenotazione pren2 = new Prenotazione(p2, "Trattamento2");

		Prenotazione pren3 = new Prenotazione(p3, "Trattamento3");

		Prenotazione pren4 = new Prenotazione(p1, "Trattamento4");

		Prenotazione pren5 = new Prenotazione(p1, "Trattamento5");

		Prenotazione pren6 = new Prenotazione(p3, "Trattamento6");

```
		o.assegnaPrenotazioneMedico(pren1);
```
```
		o.assegnaPrenotazioneMedico(pren2);
```
```
		o.assegnaPrenotazioneMedico(pren3);
```
```
		o.assegnaPrenotazioneMedico(pren4);
```
```
		o.assegnaPrenotazioneMedico(pren5);
```
```
		o.assegnaPrenotazioneMedico(pren6);
```
```
		o.assegnaPrenotazioneMedico(pren6);
```
```
		o.assegnaPrenotazioneMedico(pren6);
```
```
		o.assegnaPrenotazioneMedico(pren6);
```
```
		o.assegnaPrenotazioneMedico(pren6);
```
```
		o.assegnaPrenotazioneMedico(pren6);
```
```
		o.assegnaPrenotazioneMedico(pren6);
```
```
		o.assegnaPrenotazioneMedico(pren6);
```
```
 
```

		System.out.println("-----------------------");

```
		o.stampaStatoMedici();
```
```
 
```

		System.out.println("-----------------------");

```
		m2.curaProssimoPaziente(o);
```
```
		p1.stampaCartellaClinica();
```
```
		p2.stampaCartellaClinica();
```
```
 
```
```
		o.assegnaPrenotazioneMedico(pren6);
```
```
		o.assegnaPrenotazioneMedico(pren6);
```
```
 
```

		System.out.println("-----------------------");

```
		o.stampaStatoMedici();
```
```
 
```

		System.out.println("-----------------------");

```
		m1.curaProssimoPaziente(o);
```
```
		m1.curaProssimoPaziente(o);
```
```
		m1.curaProssimoPaziente(o);
```
```
		m1.curaProssimoPaziente(o);
```
```
 
```
```
		p1.stampaCartellaClinica();
```
```
		p2.stampaCartellaClinica();
```
```
		p3.stampaCartellaClinica();
```
```
	}
```
```
}
```

Esercizi

Lettura e Scrittura con i File di Testo

Classe Persona: modellazione di una Persona difinita da due attibuti di tipo stringa (nome e cognome)

```
public class Persona {
```
```
	private String nome;
```
```
	private String cognome;
```
```
 
```
```
	public Persona(String N, String C) {
```
```
		nome = N;
```
```
		cognome = C;
```
```
	}
```
```
 
```
```
	public void stampaInfo()
```
```
	{
```

		System.out.println("Nome: " + nome + " Cognome: " + cognome);

```
	}
```
```
 
```
```
	public String getCognome()
```
```
	{
```
```
		return cognome;
```
```
	}
```
```
 
```
```
	public String getNome()
```
```
	{
```
```
		return nome;
```
```
	}
```
```
}
```

Classe Principale Legge dal file di testo "nomi.txt" i nomi e i cognomi di tutte le persone. Ogni persona creata viene aggiunta alla lista delle persone. Gli stessi dati vengono poi salvati su un secondo file di testo, nel formato indice: cognome nome, dopo aver stampato a video tutte i dati.

```
import java.io.File;
```
```
import java.io.FileNotFoundException;
```
```
import java.io.PrintWriter;
```
```
import java.util.LinkedList;
```
```
import java.util.Scanner;
```
```
 
```
```
public class Principale {
```
```
 
```

	public static void main(String[] args) {

```
 
```

		LinkedList<Persona> lista = new LinkedList<Persona>();

```
 
```
```
		File f = new File("nomi.txt");
```
```
		File f2 = new File("output.txt");
```
```
		try {
```
```
			// Lettura da file di testo
```
```
			Scanner input = new Scanner(f);
```
```
			while(input.hasNextLine()) 
```
```
			{
```
```
				String temp = input.nextLine();
```
```
				String[] lines = temp.split(" ");
```

				Persona p = new Persona(lines[0], lines[1]);

```
				lista.add(p);
```
```
			}
```
```
			input.close();
```
```
 
```
```
			// Stampa a video di tutti i dati
```

			for (int i = 0; i < lista.size(); i++)

```
			{
```
```
				lista.get(i).stampaInfo();
```
```
			}
```
```
 
```

			// Stampa su file dei dati nel formato richiesto

			PrintWriter output = new PrintWriter(f2);

			for (int i = 0; i < lista.size(); i++)

```
			{
```

				output.println((i+1) + ": " + lista.get(i).getCognome() + " " + lista.get(i).getNome());

```
			}
```
```
			output.close();
```
```
 
```
```
		} catch (FileNotFoundException e) {
```

			System.out.println("File non trovato !!!");

```
			e.printStackTrace();
```
```
		}
```
```
	}
```
```
}
```

Lettura e Scrittura con i File Binari

Esercizio 1:

```
import java.io.IOException;
```
```
import java.io.RandomAccessFile;
```
```
import java.util.Scanner;
```
```
 
```
```
public class Principale2 {
```
```
 
```

	public static void main(String[] args) {

```
		RandomAccessFile raf;
```

		Scanner input = new Scanner(System.in);

```
		int i;
```
```
		try {
```

			// Scrittura su file binario di numeri acquisiti da tastiera

			raf = new RandomAccessFile("datiLong.dat", "rw");

```
 
```
```
			for (i = 0; i < 10; i++) {
```

				// writeInt scrive un numero intero sul file

```
				raf.writeLong(input.nextLong());
```
```
			}
```
```
 
```
```
			raf.close();
```
```
 
```

			raf = new RandomAccessFile("datiLong.dat", "r");

			System.out.println("Il file è grande: " + raf.length() + " bytes");

```
			long first, last;
```
```
 
```

			// readInt legge un numero intero dal file

```
			first = raf.readLong();
```
```
 
```

			// seek permette di muoversi all'interno del file

```
			raf.seek(raf.length() - 8);
```
```
 
```
```
 
```
```
			last = raf.readLong();
```
```
			raf.close();
```
```
 
```

			System.out.println("Il primo numero vale: " + first);

			System.out.println("L'ultimo numero vale: " + last);

```
 
```
```
		} catch (IOException e) {
```
```
			e.printStackTrace();
```
```
		}
```
```
	}
```
```
}
```

Esercizio 2:

```
import java.io.File;
```
```
import java.io.FileNotFoundException;
```
```
import java.io.IOException;
```
```
import java.io.PrintWriter;
```
```
import java.io.RandomAccessFile;
```
```
 
```
```
public class Principale3 {
```

	public static void main(String[] args) {

```
		// TODO Auto-generated method stub
```
```
		RandomAccessFile raf;
```
```
		try {
```

			raf = new RandomAccessFile("datiLong.dat", "r");

```
			int numEle = (int)(raf.length()/8);
```
```
			long[] vett = new long[numEle];
```
```
 
```
```
			for (int i = 0; i < numEle; i++)
```
```
				vett[i] = raf.readLong();
```
```
 
```
```
			raf.close();
```
```
 
```
```
			for (int i = 0; i < numEle-1; i++) {
```
```
				int i_min = i;
```

				for (int j = i+1; j < numEle; j++) {

```
					if (vett[j] < vett[i_min])
```
```
					{
```
```
						long temp = vett[j];
```
```
						vett[j] = vett[i_min];
```
```
						vett[i_min] = temp;
```
```
					}
```
```
				}
```
```
			}
```
```
 
```

			PrintWriter output = new PrintWriter(new File("output.txt"));

```
			for (int i = 0; i < numEle; i++)
```
```
				output.print(vett[i] + "\t");
```
```
			output.close();
```
```
		} catch (FileNotFoundException e) {
```
```
			// TODO Auto-generated catch block
```
```
			e.printStackTrace();
```
```
		} catch (IOException e) {
```
```
			// TODO Auto-generated catch block
```
```
			e.printStackTrace();
```
```
		}	
```
```
	}
```
```
}
```

Implemetazione dei Grafi

Metodo 1

Definizione di una class Node che modella un nodo del grafo, e di una classe Graph contenente un vettore di nodi. Ciascun nondo contiene un riferimento ad un nodo successivo.

```
public class Node {
```
```
	private String nodeID;
```
```
	private Node nextNode;
```
```
 
```
```
	public Node(String N) 
```
```
	{
```
```
		nodeID = N;
```
```
		nextNode = null;
```
```
	}
```
```
 
```
```
	public String getNodeID() 
```
```
	{
```
```
		return nodeID;
```
```
	}
```
```
 
```
```
	public void setNextNode(Node NODE) 
```
```
	{
```
```
		nextNode = NODE;
```
```
	}
```
```
 
```
```
	public Node getNextNode()
```
```
	{
```
```
		return nextNode;
```
```
	}
```
```
}
```

```
import java.io.File;
```
```
import java.io.FileNotFoundException;
```
```
import java.util.Scanner;
```
```
 
```
```
public class Graph {
```

	private final String[] labels = {"A", "B", "C", "D", "E"};

```
	private int dim;
```
```
	private Node[] listOfNodes;
```
```
 
```
```
	public Graph(int DIM, String path) {
```
```
		dim = DIM;
```
```
		listOfNodes = new Node[dim];
```
```
		for (int i = 0; i < dim; i++)
```

			listOfNodes[i] = new Node(labels[i]);

```
 
```
```
		loadFromFile(path);
```
```
	}
```
```
 
```
```
	private void loadFromFile(String path)
```
```
	{
```
```
		File f = new File(path);
```
```
		int val = 0;
```
```
		try {
```
```
			Scanner input = new Scanner(f);
```
```
			for (int i = 0; i < dim; i++)
```
```
			{
```
```
				Node head = listOfNodes[i];
```
```
				for (int j = 0; j < dim; j++) 
```
```
				{
```
```
					val = input.nextInt();
```
```
					if (val == 1)
```
```
					{
```
```
						Node n = new Node(labels[j]);
```
```
						head.setNextNode(n);
```
```
						head = head.getNextNode();
```
```
 
```
```
					}
```
```
				}
```
```
			}
```
```
			input.close();
```
```
 
```
```
 
```
```
		} catch (FileNotFoundException e) {
```
```
			// TODO Auto-generated catch block
```
```
			e.printStackTrace();
```
```
		}
```
```
	}
```
```
 
```
```
	public void print()
```
```
	{
```
```
		for (int i = 0; i < dim; i++) {
```

			System.out.print(listOfNodes[i].getNodeID() + " -> ");

			Node temp = listOfNodes[i].getNextNode();

```
			while(temp != null)
```
```
			{
```

				System.out.print(temp.getNodeID() + " -> ");

```
				temp = temp.getNextNode();
```
```
			}
```
```
			System.out.println("NULL");
```
```
		}
```
```
	}
```
```
}
```

Classe Principale con il metodo main dove viene istanziato un oggetto di tipo Graph, a partire dalla matrice delle adiacenze presente in un file di testo.

```
import java.util.Scanner;
```
```
 
```
```
public class Principale {
```

	public static void main(String[] args) {

```
		Graph g = new Graph(5, "graph.txt");
```
```
		g.print();
```
```
	}
```
```
}
```

Metodo 2

Definizione di una class Node che modella un nodo del grafo, e di una classe Graph contenente un vettore di nodi. Ciascun nodo contiente, in questo caso, una LinkedList contenente i nodi raggiungibili.

```
import java.util.LinkedList;
```
```
 
```
```
public class Node2 {
```
```
	private String nodeID;
```
```
	private LinkedList<Node2> list;
```
```
 
```
```
	public Node2(String N) 
```
```
	{
```
```
		nodeID = N;
```
```
		list = new LinkedList<Node2>();
```
```
	}
```
```
 
```
```
	public String getNodeID() {
```
```
		return nodeID;
```
```
	}
```
```
 
```
```
	public void addNode(Node2 NODE) 
```
```
	{
```
```
		list.add(NODE);
```
```
	}
```
```
 
```

	public LinkedList<Node2> getListOfNodes()

```
	{
```
```
		return list;
```
```
	}
```
```
}
```

```
import java.io.File;
```
```
import java.io.FileNotFoundException;
```
```
import java.util.Iterator;
```
```
import java.util.Scanner;
```
```
 
```
```
public class Graph2 {
```

	private final String[] labels = {"A", "B", "C", "D", "E"};

```
	private int dim;
```
```
	private Node2[] head;
```
```
 
```
```
	public Graph2(int DIM, String path) {
```
```
		dim = DIM;
```
```
		head = new Node2[dim];
```
```
		for (int i = 0; i < dim; i++)
```
```
			head[i] = new Node2(labels[i]);
```
```
 
```
```
		loadFromFile(path);
```
```
 
```
```
	}
```
```
 
```
```
	private void loadFromFile(String path)
```
```
	{
```
```
		File f = new File(path);
```
```
		int val = 0;
```
```
		try {
```
```
			Scanner input = new Scanner(f);
```
```
			for (int i = 0; i < dim; i++)
```
```
			{
```
```
				for (int j = 0; j < dim; j++) 
```
```
				{
```
```
					val = input.nextInt();
```
```
					if (val == 1)
```
```
					{
```
```
						Node2 n = new Node2(labels[j]);
```
```
						head[i].addNode(n);
```
```
					}
```
```
				}
```
```
			}
```
```
			input.close();
```
```
 
```
```
 
```
```
		} catch (FileNotFoundException e) {
```
```
			// TODO Auto-generated catch block
```
```
			e.printStackTrace();
```
```
		}
```
```
	}
```
```
 
```
```
	public void print()
```
```
	{
```
```
		for (int i = 0; i < dim; i++) {
```

			System.out.print(head[i].getNodeID() + " -> ");

			Iterator<Node2> iterator = head[i].getListOfNodes().iterator();

```
			while(iterator.hasNext())
```
```
			{
```

				System.out.print(iterator.next().getNodeID() + " -> ");

```
			}
```
```
 
```
```
			System.out.println("NULL");
```
```
		}
```
```
	}
```
```
}
```

Implementazione della classe Principale.

```
import java.util.Scanner;
```
```
 
```
```
public class Principale {
```

	public static void main(String[] args) {

		Graph2 g2 = new Graph2(5, "graph.txt");

```
		g2.print();		
```
```
	}
```
```
}
```

Metodo 3

Implementazione di un grafo tramite una HashMap. Ciascun nodo è definito da una Stinga corrispondente alla label che lo identifica.

```
import java.io.File;
```
```
import java.io.FileNotFoundException;
```
```
import java.util.ArrayList;
```
```
import java.util.HashMap;
```
```
import java.util.Iterator;
```
```
import java.util.LinkedList;
```
```
import java.util.Map;
```
```
import java.util.Scanner;
```
```
 
```
```
public class Graph4 {
```

	private final String[] labels = {"A", "B", "C", "D", "E"};

```
	private int dim;
```

	private HashMap<String, LinkedList<String>> heads;

```
 
```
```
	public Graph4(int DIM, String path) {
```
```
		dim = DIM;
```

		heads = new HashMap<String, LinkedList<String>>();

```
		for (int i = 0; i < dim; i++)
```
```
		{
```

			heads.putIfAbsent(labels[i], new LinkedList<String>());

```
		}
```
```
 
```
```
		loadFromFile(path);
```
```
 
```
```
	}
```
```
 
```
```
	private void loadFromFile(String path)
```
```
	{
```
```
		File f = new File(path);
```
```
		int val = 0;
```
```
		try {
```
```
			Scanner input = new Scanner(f);
```
```
			for (int i = 0; i < dim; i++)
```
```
			{
```
```
				for (int j = 0; j < dim; j++) 
```
```
				{
```
```
					val = input.nextInt();
```
```
					if (val == 1)
```
```
					{
```

						heads.get(labels[i]).add(labels[j]);

```
					}
```
```
				}
```
```
			}
```
```
			input.close();
```
```
 
```
```
 
```
```
		} catch (FileNotFoundException e) {
```
```
			// TODO Auto-generated catch block
```
```
			e.printStackTrace();
```
```
		}
```
```
	}
```
```
 
```
```
	public void print()
```
```
	{
```
```
		for (int i = 0; i < dim; i++) {
```

			System.out.print(labels[i] + " -> ");

			Iterator<String> iterator = heads.get(labels[i]).iterator();

```
			while(iterator.hasNext())
```
```
			{
```

				System.out.print(iterator.next() + " -> ");

```
			}
```
```
			System.out.println("NULL");
```
```
		}
```
```
	}
```
```
 
```
```
	public String[] getNodeLabels() {
```
```
		return labels;
```
```
	}
```
```
 
```

	public String[] getNextNodes(int startIDX, String[] labels)

```
	{
```

		ArrayList<String> nextNodes = new ArrayList<String>();

		Iterator<String> iterator = heads.get(labels[startIDX]).iterator();

```
		while(iterator.hasNext())
```
```
		{
```
```
			nextNodes.add(iterator.next());
```
```
		}
```
```
 
```

		String[] nextLabels = new String[nextNodes.size()];

		for (int i = 0; i < nextNodes.size(); i++)

```
			nextLabels[i] = nextNodes.get(i);
```
```
		return nextLabels;
```
```
	}
```
```
}
```

In questa implementazione della classe principale è implementato un meccanismo di navigazione del grafo. A partire da un determinato nodo, posso scegliere di muovermi su uno dei nodi raggiungibili. Anche in questo caso, la matrice delle adiacenze viene caricata da un file di teso.

```
import java.util.Scanner;
```
```
 
```
```
public class Principale {
```
```
 
```

	public static void main(String[] args) {

		Graph4 g4 = new Graph4(5, "graph.txt");

```
		g4.print();
```

		System.out.println(//////////////////////);

```
 
```
```
		// Try Navigate
```
```
		// Inserisci il nodo di partenza
```

		Scanner input = new Scanner(System.in);

		String[] availableLabels = g4.getNodeLabels();

```
 
```

		System.out.print("Inserisci nodo di partenza: ");

		for (int i = 0; i < availableLabels.length; i++)

			System.out.print(i + " per nodo " + availableLabels[i] + "; ");

```
		int node = input.nextInt();
```

		availableLabels = g4.getNextNodes(node, availableLabels);

```
 
```
```
		while(availableLabels.length > 0)
```
```
		{
```

			for (int i = 0; i < availableLabels.length; i++)

				System.out.print(i + " per nodo " + availableLabels[i] + "; ");

```
			node = input.nextInt();
```
```
			if (node == -1)
```
```
				break;
```

			availableLabels = g4.getNextNodes(node, availableLabels);

```
		}
```
```
 
```
```
		if (node == -1)
```

			System.out.println("Hai scelto di terminare il percorso !");

```
		else
```

			System.out.println("Hai raggiunto un nodo terminale");

```
 
```
```
		input.close();	
```
```
	}
```
```
}
```

Grafi e file binari

Generare un file binario contenete la matrice delle adiacenze di un grafo con dim nodi. Nello specifico, ciascuna posizione M(i,j) della matriece conterrà 0 se non esiste un percoso da i a j, altrimenti un numero maggiore di 0 che indica il costo per andare dal nodo i al nodo j. Successivamente creare il grafo a partire dalla matrice contenuta nel file binario, navigarlo e salvare il percorso e il relativo costo su un file di testo.

Definizione della classe FileGenerator che implementerà le funzioni di scrittura del file binario e del file di testo.

```
import java.io.File;
```
```
import java.io.FileNotFoundException;
```
```
import java.io.IOException;
```
```
import java.io.PrintWriter;
```
```
import java.io.RandomAccessFile;
```
```
import java.util.Iterator;
```
```
import java.util.LinkedList;
```
```
import java.util.Scanner;
```
```
 
```
```
public class FileGenerator {
```
```
	public void generateGraphFile() {
```
```
		try {
```

			RandomAccessFile raf = new RandomAccessFile("dati.dat",  "rw");

			System.out.println("Inserisci Dimensione: ");

			Scanner input = new Scanner(System.in);

```
			int dim = input.nextInt();
```
```
			raf.writeInt(dim);
```
```
			for (int i = 0; i < dim; i++) {
```
```
				for (int j = 0; j < dim; j++)
```
```
				{
```

					System.out.print("Inserisci costo per andare da " + (char)('A'+i) + " a " + (char)('A'+j) + ": ");

```
					raf.writeInt(input.nextInt());
```
```
				}
```
```
			}
```
```
			//input.close();
```
```
			raf.close();
```
```
		} catch (FileNotFoundException e) {
```
```
			// TODO Auto-generated catch block
```
```
			e.printStackTrace();
```
```
		} catch (IOException e) {
```
```
			// TODO Auto-generated catch block
```
```
			e.printStackTrace();
```
```
		}
```
```
	}
```
```
 
```

	public void savePathToFile(LinkedList<Character> percorso, int costo)

```
	{
```
```
		try {
```

			PrintWriter output = new PrintWriter(new File("output.txt"));

			Iterator<Character> listIterator = percorso.iterator();

```
			while (listIterator.hasNext())
```
```
			{
```

				output.print(listIterator.next() + " -> ");

```
			}
```
```
			output.println("END");
```
```
 
```

			output.println("Costo del percorso: " + costo);

```
			output.close();
```
```
 
```
```
		} catch (FileNotFoundException e) {
```
```
			// TODO Auto-generated catch block
```
```
			e.printStackTrace();
```
```
		}
```
```
	}
```
```
}
```

Implmentazione della classe Graph. In questo caso, il grafo è gestito come una matrice di interi.

```
import java.io.FileNotFoundException;
```
```
import java.io.IOException;
```
```
import java.io.RandomAccessFile;
```
```
import java.util.ArrayList;
```
```
 
```
```
public class Graph {
```
```
	private int dim;
```
```
	private int[][] matrix;
```
```
 
```
```
	public Graph(String path) {
```
```
		try {
```

			RandomAccessFile inputFile = new RandomAccessFile(path, "r");

```
			inputFile.seek(0);
```
```
			dim = inputFile.readInt();
```
```
			matrix = new int[dim][dim];
```
```
			for (int i = 0; i < dim; i++) {
```
```
				for (int j = 0; j < dim; j++) {
```

					matrix[i][j] = inputFile.readInt();

```
				}
```
```
			}
```
```
			inputFile.close();
```
```
 
```
```
		} catch (FileNotFoundException e) {
```
```
			// TODO Auto-generated catch block
```
```
			e.printStackTrace();
```
```
		} catch (IOException e) {
```
```
			// TODO Auto-generated catch block
```
```
			e.printStackTrace();
```
```
		}
```
```
	}
```
```
 
```
```
	public void printGraph() 
```
```
	{
```

		System.out.println("/////////////////");

```
		System.out.println("Graph");
```
```
		for (int i = 0; i < dim; i++)
```

			System.out.print((char)('A'+i) + "\t");

```
		System.out.println();
```
```
		for (int i = 0; i < dim; i++) {
```
```
			for (int j = 0; j < dim; j++) {
```

				System.out.print(matrix[i][j] + "\t");

```
			}
```
```
			System.out.println();
```
```
		}
```
```
	}
```
```
 
```
```
	public int getDim()
```
```
	{
```
```
		return dim;
```
```
	}
```
```
 
```

	public ArrayList<Integer> getNextNodes(int node)

```
	{
```

		ArrayList<Integer> temp = new ArrayList<Integer>();

```
		for (int i = 0; i < dim; i++)
```
```
		{
```
```
			if (matrix[node][i] > 0)
```
```
				temp.add(i);
```
```
		}
```
```
 
```
```
		return temp;
```
```
	}
```
```
 
```
```
	public int getCosto(int i, int j)
```
```
	{
```
```
		return matrix[i][j];
```
```
	}
```
```
}
```

Implmentazione della classe Principale, dove sono richiamate le opportune funzioni.

```
import java.util.ArrayList;
```
```
import java.util.LinkedList;
```
```
import java.util.Scanner;
```
```
 
```
```
public class Principale {
```

	public static void main(String[] args) {

		long startTime = System.currentTimeMillis();

		FileGenerator fg = new FileGenerator();

```
		//fg.generateGraphFile();
```
```
		Graph g = new Graph("dati.dat");
```
```
		g.printGraph();
```

		System.out.println(System.currentTimeMillis() - startTime);

```
 
```

		///////////////////////////////////////

```
		// Try Navigate
```
```
		// Inserisci il nodo di partenza
```

		Scanner input = new Scanner(System.in);

		LinkedList<Character> percorso = new LinkedList<Character>();

```
 
```

		ArrayList<Integer> nextNodes = new ArrayList<Integer>();

```
		int costo = 0;
```

		System.out.print("Inserisci nodo di partenza: ");

```
		for (int i = 0; i < g.getDim(); i++)
```

			System.out.print(i + " per nodo " + (char)('A'+i) + "; ");

```
 
```
```
		int node = input.nextInt();
```
```
		percorso.add(((char)('A'+node)));
```
```
		nextNodes = g.getNextNodes(node);
```

		System.out.println("Sei sul nodo: " + (char)('A'+node));

```
 
```
```
		while(nextNodes.size() > 0)
```
```
		{
```

			for (int i = 0; i < nextNodes.size(); i++)

				System.out.print(i + " per nodo " + (char)('A'+nextNodes.get(i)) + "; ");

```
			int temp = node;
```
```
			node = input.nextInt();
```
```
			if (node == -1)
```
```
				break;
```
```
			percorso.add(((char)('A'+node)));
```

			costo = costo + g.getCosto(temp, nextNodes.get(node));

			System.out.println("Sei sul nodo: " + (char)('A'+nextNodes.get(node)));

```
			nextNodes = g.getNextNodes(node);
```
```
		}
```
```
 
```
```
		if (node == -1)
```

			System.out.println("Hai scelto di terminare il percorso !");

```
		else
```

			System.out.println("Hai raggiunto un nodo terminale");

		System.out.println("Costo del percorso effettuato: " + costo);

```
 
```
```
		input.close(); 
```
```
 
```
```
		fg.savePathToFile(percorso, costo);
```
```
	}
```
```
}
```

Classi astratte e metodi astratti

Esercitazione JAVA 2019

Indice

Implementazione completa di uno scenario ospedaliero

Modellazione dello Scenario

Implementazione della coda

Esercizi

Lettura e Scrittura con i File di Testo

Lettura e Scrittura con i File Binari

Implemetazione dei Grafi

Metodo 1

Metodo 2

Metodo 3

Grafi e file binari

Classi astratte e metodi astratti

Menu di navigazione

Strumenti personali

Namespace

Varianti

Visite

Azioni

Ricerca

Navigazione

Strumenti