Esercitazione JAVA 2019: differenze tra le versioni

Da Bioingegneria Elettronica e Informatica.
(→‎Grafi e file binari)
(→‎Grafi e file binari)
Riga 1 167: Riga 1 167:
  
 
== Grafi e file binari ==
 
== 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 da i a j.
+
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.
 
<syntaxhighlight lang="java" line>
 
<syntaxhighlight lang="java" line>
 +
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();
 +
}
 +
}
 +
}
 +
 +
</syntaxhighlight>
 +
 +
Implmentazione della classe Graph. In questo caso, il grafo è gestito come una matrice di interi.
 +
<syntaxhighlight lang="java" line>
 +
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];
 +
}
 +
}
 +
 +
</syntaxhighlight>
 +
 +
Implmentazione della classe Principale, dove sono richiamate le opportune funzioni.
 +
<syntaxhighlight lang="java" line>
 +
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);
 +
}
 +
}
 +
 
</syntaxhighlight>
 
</syntaxhighlight>

Versione delle 11:39, 31 mag 2019


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. 

  1. public class Persona {
  2. 	protected String nome;
  3. 	protected String cognome;
  4. 	protected String CF;
  5.  
  6. 	public Persona(String N, String C, String cf)
  7. 	{
  8. 		nome = N;
  9. 		cognome = C;
  10. 		CF = cf;
  11. 	}
  12. }


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

  1. public class Medico extends Persona {
  2.  
  3. 	private String specializzazione;
  4.  
  5. 	public Medico(String N, String C, String cf, String spec) {
  6. 		super(N, C, cf);
  7. 		specializzazione = spec;	
  8. 	}
  9.  
  10. 	public String getInfo()
  11. 	{
  12. 		String info = nome + "\t" + cognome + "\t" + CF + "\t" + specializzazione;
  13. 		return info;
  14. 	}
  15.  
  16. }


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

  1. public class Paziente extends Persona {
  2.  
  3. 	private String diagnosi;
  4.  
  5. 	public Paziente(String N, String C, String cf, String D) {
  6. 		super(N, C, cf);
  7. 		diagnosi = D;
  8. 	}
  9.  
  10. 	public String getInfo()
  11. 	{
  12. 		String info = nome + "\t" + cognome + "\t" + CF + "\t" + diagnosi;
  13. 		return info;
  14. 	}
  15.  
  16. }


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. 

  1. import java.util.ArrayList;
  2. import java.util.LinkedList;
  3.  
  4. public class Ospedale {
  5. 	private String nomeOspedale;
  6.  
  7. 	private ArrayList<Medico> listaMedici;
  8. 	private LinkedList<Paziente> listaPazienti;
  9.  
  10. 	public Ospedale(String N)
  11. 	{
  12. 		nomeOspedale = N;
  13. 		listaMedici = new ArrayList<Medico>();
  14. 		listaPazienti = new LinkedList<Paziente>();
  15. 	}
  16.  
  17. 	public void aggiungiMedici(Medico M)
  18. 	{
  19. 		listaMedici.add(M);
  20. 		System.out.println("Medico Aggiunto");
  21. 	}
  22.  
  23. 	public void aggiungiMedici(ArrayList<Medico> LM)
  24. 	{
  25. 		listaMedici.addAll(LM);
  26. 		System.out.println("Medici Aggiunti");
  27. 	}
  28.  
  29. 	public void aggiungiPazienti(Paziente P)
  30. 	{
  31. 		listaPazienti.add(P);
  32. 		System.out.println("Paziente Aggiunto");
  33. 	}
  34.  
  35. 	public void aggiungiPazienti(ArrayList<Paziente> LP)
  36. 	{
  37. 		listaPazienti.addAll(LP);
  38. 		System.out.println("Pazienti Aggiunti");
  39. 	}
  40.  
  41. 	public void stampaMedici()
  42. 	{
  43. 		System.out.println("Lista Medici:");
  44. 		for (int i = 0; i < listaMedici.size(); i++)
  45. 		{
  46. 			System.out.println((i+1) + ": " + listaMedici.get(i).getInfo());
  47. 		}
  48. 	}
  49.  
  50. 	public void stampaPazienti()
  51. 	{
  52. 		System.out.println("Lista Pazienti:");
  53. 		for (int i = 0; i < listaPazienti.size(); i++)
  54. 		{
  55. 			System.out.println((i+1) + ": " + listaPazienti.get(i).getInfo());
  56. 		}
  57. 	}
  58. }


Classe Principale: classe che contiene il metodo main. 

  1. import java.util.ArrayList;
  2.  
  3. public class Principale {
  4.  
  5. 	public static void main(String[] args) {
  6.  
  7. 		Ospedale o = new Ospedale("Policlinico");
  8.  
  9. 		Medico m1 = new Medico("M_Nome1", "M_Cognome1", "M_Codice1", "Chirurgia");
  10. 		Medico m2 = new Medico("M_Nome2", "M_Cognome2", "M_Codice2", "Radiologia");
  11. 		Medico m3 = new Medico("M_Nome3", "M_Cognome3", "M_Codice3", "Cardiologia");
  12.  
  13. 		ArrayList<Medico> lm = new ArrayList<Medico>();
  14. 		lm.add(m1);
  15. 		lm.add(m3);
  16. 		o.aggiungiMedici(m2);
  17. 		o.aggiungiMedici(lm);
  18.  
  19. 		Paziente p1 = new Paziente("P_Nome1", "P_Cognome1", "P_Codice1", "Frattura");
  20. 		Paziente p2 = new Paziente("P_Nome2", "P_Cognome2", "P_Codice2", "Tumore");
  21. 		Paziente p3 = new Paziente("P_Nome3", "P_Cognome3", "P_Codice3", "Infarto");
  22.  
  23. 		ArrayList<Paziente> lp = new ArrayList<Paziente>();
  24. 		lp.add(p1);
  25. 		lp.add(p2);
  26. 		o.aggiungiPazienti(p3);
  27. 		o.aggiungiPazienti(lp);
  28.  
  29. 		System.out.println();
  30. 		System.out.println("////////////////////////////////////////////////");
  31. 		o.stampaMedici();
  32. 		System.out.println();
  33. 		o.stampaPazienti();
  34.  
  35. 	}
  36. }


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. 

  1. public class Persona {
  2. 	protected String nome;
  3. 	protected String cognome;
  4. 	protected String CF;
  5.  
  6. 	public Persona(String N, String C, String cf)
  7. 	{
  8. 		nome = N;
  9. 		cognome = C;
  10. 		CF = cf;
  11. 	}
  12.  
  13. 	public String getNome()
  14. 	{
  15. 		return nome;
  16. 	}
  17.  
  18. 	public String getCognome()
  19. 	{
  20. 		return cognome;
  21. 	}
  22.  
  23. 	public String getCF()
  24. 	{
  25. 		return CF;
  26. 	}
  27. }

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

  1. public class Medico extends Persona {
  2.  
  3. 	private String specializzazione;
  4.  
  5. 	private Prenotazione[] codaPrenotazioni;
  6.  
  7. 	// Variabili per la gestione della coda
  8. 	private int head;
  9. 	private int tail;
  10. 	private int length;
  11. 	private int size;
  12.  
  13. 	public Medico(String N, String C, String cf, 
  14. 			String spec, int DimCoda) {
  15. 		super(N, C, cf);
  16. 		specializzazione = spec;	
  17.  
  18. 		length = DimCoda;
  19. 		head = 0;
  20. 		tail = 0;
  21. 		size = 0;
  22.  
  23. 		codaPrenotazioni = new Prenotazione[length];
  24. 	}
  25.  
  26. 	public String getInfo()
  27. 	{
  28. 		String info = nome + "\t" + cognome + "\t" + CF + "\t" + specializzazione;
  29. 		return info;
  30. 	}
  31.  
  32. 	public boolean isAvailable()
  33. 	{
  34. 		if (size == length)
  35. 			return false;
  36. 		return true;
  37. 	}
  38.  
  39. 	public int utentiInCoda()
  40. 	{
  41. 		return size;
  42. 	}
  43.  
  44.  
  45. 	public void stampaStatoCoda()
  46. 	{
  47. 		int i = 0;
  48. 		if (size == 0)
  49. 			System.out.println("Nessuna prenotazione");
  50. 		else
  51. 		{
  52. 			System.out.println("Prenotazioni in coda:");
  53. 			for (i = 0; i < size; i++) {
  54. 				System.out.println((i+1) + "\t" + codaPrenotazioni[(head + i) % length].stampaInfoPrenotazione());
  55. 			}
  56. 		}
  57. 		System.out.println();
  58. 	}
  59.  
  60. 	public void accettaPazienteInCoda(Prenotazione P)
  61. 	{
  62. 		codaPrenotazioni[tail] = P;
  63. 		tail = (tail + 1) % length;
  64. 		size++;
  65. 	}
  66.  
  67. 	public void curaProssimoPaziente(Ospedale o) 
  68. 	{
  69. 		if (size == 0)
  70. 		{
  71. 			System.out.println("Nessuna Prenotazione in coda");
  72. 		}
  73. 		else {
  74. 			Prenotazione temp = codaPrenotazioni[head];
  75. 			head = (head + 1) % length;
  76. 			size--;
  77.  
  78. 			eseguiVisita(temp, o);
  79. 		}
  80. 	}
  81.  
  82. 	private void eseguiVisita(Prenotazione p, Ospedale o)
  83. 	{
  84. 		Visita v = new Visita(this.CF, p.getPaziente().getDiagnosi(), p.getTrattamento(), o.getNome());
  85. 		p.getPaziente().aggiungiVisita(v);
  86. 	}
  87. }

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. 

  1. import java.util.LinkedList;
  2.  
  3. public class Paziente extends Persona {
  4.  
  5. 	private String diagnosi;
  6. 	private LinkedList<Visita> cartellaClinica;
  7.  
  8. 	public Paziente(String N, String C, String cf, String D) {
  9. 		super(N, C, cf);
  10. 		diagnosi = D;
  11. 		cartellaClinica = new LinkedList<Visita>();
  12. 	}
  13.  
  14. 	public String getInfo()
  15. 	{
  16. 		String info = nome + "\t" + cognome + "\t" + CF + "\t" + diagnosi;
  17. 		return info;
  18. 	}
  19.  
  20. 	public String getDiagnosi()
  21. 	{
  22. 		return diagnosi;
  23. 	}
  24.  
  25. 	public void aggiungiVisita(Visita v)
  26. 	{
  27. 		cartellaClinica.add(v);
  28. 	}
  29.  
  30. 	public void stampaCartellaClinica() 
  31. 	{
  32. 		System.out.println("Paziente:\t" + nome + "\t" + cognome);
  33. 		if (cartellaClinica.size() == 0)
  34. 		{
  35. 			System.out.println("Nessuna visita effettuata finora");
  36. 		}
  37. 		else
  38. 		{
  39. 			for (int i = 0; i < cartellaClinica.size(); i++)
  40. 			{
  41. 				cartellaClinica.get(i).stampaInformazioniVisita();
  42. 			}
  43. 		}
  44. 	}
  45. }


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. 

  1. import java.util.ArrayList;
  2. import java.util.LinkedList;
  3.  
  4. public class Ospedale {
  5. 	private String nomeOspedale;
  6.  
  7. 	private ArrayList<Medico> listaMedici;
  8. 	private LinkedList<Paziente> listaPazienti;
  9.  
  10.  
  11. 	public Ospedale(String N)
  12. 	{
  13. 		nomeOspedale = N;
  14. 		listaMedici = new ArrayList<Medico>();
  15. 		listaPazienti = new LinkedList<Paziente>();
  16. 	}
  17.  
  18. 	public String getNome()
  19. 	{
  20. 		return nomeOspedale;
  21. 	}
  22.  
  23. 	public void aggiungiMedici(Medico M)
  24. 	{
  25. 		listaMedici.add(M);
  26. 		System.out.println("Medico Aggiunto");
  27. 	}
  28.  
  29. 	public void aggiungiMedici(ArrayList<Medico> LM)
  30. 	{
  31. 		listaMedici.addAll(LM);
  32. 		System.out.println("Medici Aggiunti");
  33. 	}
  34.  
  35. 	public void aggiungiPazienti(Paziente P)
  36. 	{
  37. 		listaPazienti.add(P);
  38. 		System.out.println("Paziente Aggiunto");
  39. 	}
  40.  
  41. 	public void aggiungiPazienti(ArrayList<Paziente> LP)
  42. 	{
  43. 		listaPazienti.addAll(LP);
  44. 		System.out.println("Pazienti Aggiunti");
  45. 	}
  46.  
  47. 	public void stampaMedici()
  48. 	{
  49. 		System.out.println("Lista Medici:");
  50. 		for (int i = 0; i < listaMedici.size(); i++)
  51. 		{
  52. 			System.out.println((i+1) + ": " + listaMedici.get(i).getInfo());
  53. 		}
  54. 	}
  55.  
  56. 	public void stampaPazienti()
  57. 	{
  58. 		System.out.println("Lista Pazienti:");
  59. 		for (int i = 0; i < listaPazienti.size(); i++)
  60. 		{
  61. 			System.out.println((i+1) + ": " + listaPazienti.get(i).getInfo());
  62. 		}
  63. 	}
  64.  
  65. 	public void assegnaPrenotazioneMedico(Prenotazione P)
  66. 	{
  67. 		int idx = trovaMedicoLibero();
  68. 		if (idx > -1)
  69. 			listaMedici.get(idx).accettaPazienteInCoda(P);
  70. 		else
  71. 			System.out.println("Nessun medico disponibile ad accettare la prenotazione " + P.stampaInfoPrenotazione());
  72. 	}
  73.  
  74. 	private int trovaMedicoLibero () 
  75. 	{
  76. 		// Restituisce l'indice della lista dei medici con il medico con meno utenti in coda
  77. 		int idx_min = -1;
  78. 		if (listaMedici.size() != 0)
  79. 		{
  80. 			// Devo trovare il primo medico disponibile
  81. 			for(int i = 0; i < listaMedici.size(); i++)
  82. 			{
  83. 				if(listaMedici.get(i).isAvailable())
  84. 				{
  85. 					idx_min = i;
  86. 					break;
  87. 				}
  88. 			}
  89. 		}
  90. 		if (idx_min > -1)
  91. 		{
  92. 			for (int i = idx_min + 1; i < listaMedici.size(); i++) 
  93. 			{
  94. 				if (listaMedici.get(i).isAvailable() &&  (listaMedici.get(i).utentiInCoda() < listaMedici.get(idx_min).utentiInCoda()))
  95. 				{
  96. 					idx_min = i;
  97. 				}
  98. 			}
  99.  
  100. 		}
  101. 		return idx_min;
  102. 	}
  103.  
  104. 	public void stampaStatoMedici()
  105. 	{
  106. 		for (int i = 0; i < listaMedici.size(); i++)
  107. 		{
  108. 			System.out.println("Medico: " + listaMedici.get(i).getCognome());
  109. 			listaMedici.get(i).stampaStatoCoda();
  110. 		}
  111. 	}
  112.  
  113. }

Classe Prenotazione: modella la prenotazione di un paziente 

  1. public class Prenotazione {
  2.  
  3. 	private Paziente p;
  4. 	private String trattamento;
  5.  
  6. 	public Prenotazione(Paziente P, String T)
  7. 	{
  8. 		p = P;
  9. 		trattamento = T;
  10. 	}
  11.  
  12. 	public String stampaInfoPrenotazione()
  13. 	{
  14. 		String info = "Paziente:\t" + p.getCF() + "\tTrattamento: " + trattamento;
  15. 		return info;
  16. 	}
  17.  
  18. 	public Paziente getPaziente() 
  19. 	{
  20. 		return p;
  21. 	}
  22.  
  23. 	public String getTrattamento() 
  24. 	{
  25. 		return trattamento;
  26. 	}
  27. }

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

  1. public class Visita {
  2. 	private String medico;
  3. 	private String diagnosi;
  4. 	private String trattamento;
  5. 	private String ospedale;
  6.  
  7. 	public Visita(String M, String D, String T, String O)
  8. 	{	
  9. 		medico = M;
  10. 		diagnosi = D;
  11. 		trattamento = T;
  12. 		ospedale = O;
  13. 	}
  14.  
  15. 	public void stampaInformazioniVisita() 
  16. 	{
  17. 		System.out.println("Diagnosi:  " + diagnosi	+ " Visita effettuata dal medico: " + medico + " che ha eseguito il seguente trattamento: " + trattamento + 
  18. 				" presso il seguente ospedale: " + ospedale);
  19. 	}
  20. }


Classe Principale: classe che contiene il metodo main. 

  1. import java.util.ArrayList;
  2.  
  3. public class Principale {
  4.  
  5. 	public static void main(String[] args) {
  6.  
  7. 		Ospedale o = new Ospedale("Policlinico");
  8.  
  9. 		Medico m1 = new Medico("M_Nome1", "M_Cognome1", "M_Codice1", "Chirurgia", 3);
  10. 		Medico m2 = new Medico("M_Nome2", "M_Cognome2", "M_Codice2", "Radiologia", 3);
  11. 		Medico m3 = new Medico("M_Nome3", "M_Cognome3", "M_Codice3", "Cardiologia", 5);
  12.  
  13. 		ArrayList<Medico> lm = new ArrayList<Medico>();
  14. 		lm.add(m1);
  15. 		lm.add(m3);
  16. 		o.aggiungiMedici(m2);
  17. 		o.aggiungiMedici(lm);
  18.  
  19. 		Paziente p1 = new Paziente("P_Nome1", "P_Cognome1", "P_Codice1", "Frattura");
  20. 		Paziente p2 = new Paziente("P_Nome2", "P_Cognome2", "P_Codice2", "Tumore");
  21. 		Paziente p3 = new Paziente("P_Nome3", "P_Cognome3", "P_Codice3", "Infarto");
  22.  
  23. 		ArrayList<Paziente> lp = new ArrayList<Paziente>();
  24. 		lp.add(p1);
  25. 		lp.add(p2);
  26. 		o.aggiungiPazienti(p3);
  27. 		o.aggiungiPazienti(lp);
  28.  
  29. 		System.out.println();
  30. 		System.out.println("////////////////////////////////////////////////");
  31. 		o.stampaMedici();
  32. 		System.out.println();
  33. 		o.stampaPazienti();
  34.  
  35. 		Prenotazione pren1 = new Prenotazione(p1, "Trattamento1");
  36. 		Prenotazione pren2 = new Prenotazione(p2, "Trattamento2");
  37. 		Prenotazione pren3 = new Prenotazione(p3, "Trattamento3");
  38. 		Prenotazione pren4 = new Prenotazione(p1, "Trattamento4");
  39. 		Prenotazione pren5 = new Prenotazione(p1, "Trattamento5");
  40. 		Prenotazione pren6 = new Prenotazione(p3, "Trattamento6");
  41. 		o.assegnaPrenotazioneMedico(pren1);
  42. 		o.assegnaPrenotazioneMedico(pren2);
  43. 		o.assegnaPrenotazioneMedico(pren3);
  44. 		o.assegnaPrenotazioneMedico(pren4);
  45. 		o.assegnaPrenotazioneMedico(pren5);
  46. 		o.assegnaPrenotazioneMedico(pren6);
  47. 		o.assegnaPrenotazioneMedico(pren6);
  48. 		o.assegnaPrenotazioneMedico(pren6);
  49. 		o.assegnaPrenotazioneMedico(pren6);
  50. 		o.assegnaPrenotazioneMedico(pren6);
  51. 		o.assegnaPrenotazioneMedico(pren6);
  52. 		o.assegnaPrenotazioneMedico(pren6);
  53. 		o.assegnaPrenotazioneMedico(pren6);
  54.  
  55. 		System.out.println("-----------------------");
  56. 		o.stampaStatoMedici();
  57.  
  58. 		System.out.println("-----------------------");
  59. 		m2.curaProssimoPaziente(o);
  60. 		p1.stampaCartellaClinica();
  61. 		p2.stampaCartellaClinica();
  62.  
  63. 		o.assegnaPrenotazioneMedico(pren6);
  64. 		o.assegnaPrenotazioneMedico(pren6);
  65.  
  66. 		System.out.println("-----------------------");
  67. 		o.stampaStatoMedici();
  68.  
  69. 		System.out.println("-----------------------");
  70. 		m1.curaProssimoPaziente(o);
  71. 		m1.curaProssimoPaziente(o);
  72. 		m1.curaProssimoPaziente(o);
  73. 		m1.curaProssimoPaziente(o);
  74.  
  75. 		p1.stampaCartellaClinica();
  76. 		p2.stampaCartellaClinica();
  77. 		p3.stampaCartellaClinica();
  78. 	}
  79. }


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) 

  1. public class Persona {
  2. 	private String nome;
  3. 	private String cognome;
  4.  
  5. 	public Persona(String N, String C) {
  6. 		nome = N;
  7. 		cognome = C;
  8. 	}
  9.  
  10. 	public void stampaInfo()
  11. 	{
  12. 		System.out.println("Nome: " + nome + " Cognome: " + cognome);
  13. 	}
  14.  
  15. 	public String getCognome()
  16. 	{
  17. 		return cognome;
  18. 	}
  19.  
  20. 	public String getNome()
  21. 	{
  22. 		return nome;
  23. 	}
  24. }

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. 

  1. import java.io.File;
  2. import java.io.FileNotFoundException;
  3. import java.io.PrintWriter;
  4. import java.util.LinkedList;
  5. import java.util.Scanner;
  6.  
  7. public class Principale {
  8.  
  9. 	public static void main(String[] args) {
  10.  
  11. 		LinkedList<Persona> lista = new LinkedList<Persona>();
  12.  
  13. 		File f = new File("nomi.txt");
  14. 		File f2 = new File("output.txt");
  15. 		try {
  16. 			// Lettura da file di testo
  17. 			Scanner input = new Scanner(f);
  18. 			while(input.hasNextLine()) 
  19. 			{
  20. 				String temp = input.nextLine();
  21. 				String[] lines = temp.split(" ");
  22. 				Persona p = new Persona(lines[0], lines[1]);
  23. 				lista.add(p);
  24. 			}
  25. 			input.close();
  26.  
  27. 			// Stampa a video di tutti i dati
  28. 			for (int i = 0; i < lista.size(); i++)
  29. 			{
  30. 				lista.get(i).stampaInfo();
  31. 			}
  32.  
  33. 			// Stampa su file dei dati nel formato richiesto
  34. 			PrintWriter output = new PrintWriter(f2);
  35. 			for (int i = 0; i < lista.size(); i++)
  36. 			{
  37. 				output.println((i+1) + ": " + lista.get(i).getCognome() + " " + lista.get(i).getNome());
  38. 			}
  39. 			output.close();
  40.  
  41. 		} catch (FileNotFoundException e) {
  42. 			System.out.println("File non trovato !!!");
  43. 			e.printStackTrace();
  44. 		}
  45. 	}
  46. }

Lettura e Scrittura con i File Binari

Esercizio 1: 

  1. import java.io.IOException;
  2. import java.io.RandomAccessFile;
  3. import java.util.Scanner;
  4.  
  5. public class Principale2 {
  6.  
  7. 	public static void main(String[] args) {
  8. 		RandomAccessFile raf;
  9. 		Scanner input = new Scanner(System.in);
  10. 		int i;
  11. 		try {
  12. 			// Scrittura su file binario di numeri acquisiti da tastiera
  13. 			raf = new RandomAccessFile("datiLong.dat", "rw");
  14.  
  15. 			for (i = 0; i < 10; i++) {
  16. 				// writeInt scrive un numero intero sul file
  17. 				raf.writeLong(input.nextLong());
  18. 			}
  19.  
  20. 			raf.close();
  21.  
  22. 			raf = new RandomAccessFile("datiLong.dat", "r");
  23. 			System.out.println("Il file è grande: " + raf.length() + " bytes");
  24. 			long first, last;
  25.  
  26. 			// readInt legge un numero intero dal file
  27. 			first = raf.readLong();
  28.  
  29. 			// seek permette di muoversi all'interno del file
  30. 			raf.seek(raf.length() - 8);
  31.  
  32.  
  33. 			last = raf.readLong();
  34. 			raf.close();
  35.  
  36. 			System.out.println("Il primo numero vale: " + first);
  37. 			System.out.println("L'ultimo numero vale: " + last);
  38.  
  39. 		} catch (IOException e) {
  40. 			e.printStackTrace();
  41. 		}
  42. 	}
  43. }

Esercizio 2: 

  1. import java.io.File;
  2. import java.io.FileNotFoundException;
  3. import java.io.IOException;
  4. import java.io.PrintWriter;
  5. import java.io.RandomAccessFile;
  6.  
  7. public class Principale3 {
  8. 	public static void main(String[] args) {
  9. 		// TODO Auto-generated method stub
  10. 		RandomAccessFile raf;
  11. 		try {
  12. 			raf = new RandomAccessFile("datiLong.dat", "r");
  13. 			int numEle = (int)(raf.length()/8);
  14. 			long[] vett = new long[numEle];
  15.  
  16. 			for (int i = 0; i < numEle; i++)
  17. 				vett[i] = raf.readLong();
  18.  
  19. 			raf.close();
  20.  
  21. 			for (int i = 0; i < numEle-1; i++) {
  22. 				int i_min = i;
  23. 				for (int j = i+1; j < numEle; j++) {
  24. 					if (vett[j] < vett[i_min])
  25. 					{
  26. 						long temp = vett[j];
  27. 						vett[j] = vett[i_min];
  28. 						vett[i_min] = temp;
  29. 					}
  30. 				}
  31. 			}
  32.  
  33. 			PrintWriter output = new PrintWriter(new File("output.txt"));
  34. 			for (int i = 0; i < numEle; i++)
  35. 				output.print(vett[i] + "\t");
  36. 			output.close();
  37. 		} catch (FileNotFoundException e) {
  38. 			// TODO Auto-generated catch block
  39. 			e.printStackTrace();
  40. 		} catch (IOException e) {
  41. 			// TODO Auto-generated catch block
  42. 			e.printStackTrace();
  43. 		}	
  44. 	}
  45. }

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. 

  1. public class Node {
  2. 	private String nodeID;
  3. 	private Node nextNode;
  4.  
  5. 	public Node(String N) 
  6. 	{
  7. 		nodeID = N;
  8. 		nextNode = null;
  9. 	}
  10.  
  11. 	public String getNodeID() 
  12. 	{
  13. 		return nodeID;
  14. 	}
  15.  
  16. 	public void setNextNode(Node NODE) 
  17. 	{
  18. 		nextNode = NODE;
  19. 	}
  20.  
  21. 	public Node getNextNode()
  22. 	{
  23. 		return nextNode;
  24. 	}
  25. }


  1. import java.io.File;
  2. import java.io.FileNotFoundException;
  3. import java.util.Scanner;
  4.  
  5. public class Graph {
  6. 	private final String[] labels = {"A", "B", "C", "D", "E"};
  7. 	private int dim;
  8. 	private Node[] listOfNodes;
  9.  
  10. 	public Graph(int DIM, String path) {
  11. 		dim = DIM;
  12. 		listOfNodes = new Node[dim];
  13. 		for (int i = 0; i < dim; i++)
  14. 			listOfNodes[i] = new Node(labels[i]);
  15.  
  16. 		loadFromFile(path);
  17. 	}
  18.  
  19. 	private void loadFromFile(String path)
  20. 	{
  21. 		File f = new File(path);
  22. 		int val = 0;
  23. 		try {
  24. 			Scanner input = new Scanner(f);
  25. 			for (int i = 0; i < dim; i++)
  26. 			{
  27. 				Node head = listOfNodes[i];
  28. 				for (int j = 0; j < dim; j++) 
  29. 				{
  30. 					val = input.nextInt();
  31. 					if (val == 1)
  32. 					{
  33. 						Node n = new Node(labels[j]);
  34. 						head.setNextNode(n);
  35. 						head = head.getNextNode();
  36.  
  37. 					}
  38. 				}
  39. 			}
  40. 			input.close();
  41.  
  42.  
  43. 		} catch (FileNotFoundException e) {
  44. 			// TODO Auto-generated catch block
  45. 			e.printStackTrace();
  46. 		}
  47. 	}
  48.  
  49. 	public void print()
  50. 	{
  51. 		for (int i = 0; i < dim; i++) {
  52. 			System.out.print(listOfNodes[i].getNodeID() + " -> ");
  53. 			Node temp = listOfNodes[i].getNextNode();
  54. 			while(temp != null)
  55. 			{
  56. 				System.out.print(temp.getNodeID() + " -> ");
  57. 				temp = temp.getNextNode();
  58. 			}
  59. 			System.out.println("NULL");
  60. 		}
  61. 	}
  62. }

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. 

  1. import java.util.Scanner;
  2.  
  3. public class Principale {
  4. 	public static void main(String[] args) {
  5. 		Graph g = new Graph(5, "graph.txt");
  6. 		g.print();
  7. 	}
  8. }

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. 

  1. import java.util.LinkedList;
  2.  
  3. public class Node2 {
  4. 	private String nodeID;
  5. 	private LinkedList<Node2> list;
  6.  
  7. 	public Node2(String N) 
  8. 	{
  9. 		nodeID = N;
  10. 		list = new LinkedList<Node2>();
  11. 	}
  12.  
  13. 	public String getNodeID() {
  14. 		return nodeID;
  15. 	}
  16.  
  17. 	public void addNode(Node2 NODE) 
  18. 	{
  19. 		list.add(NODE);
  20. 	}
  21.  
  22. 	public LinkedList<Node2> getListOfNodes()
  23. 	{
  24. 		return list;
  25. 	}
  26. }


  1. import java.io.File;
  2. import java.io.FileNotFoundException;
  3. import java.util.Iterator;
  4. import java.util.Scanner;
  5.  
  6. public class Graph2 {
  7. 	private final String[] labels = {"A", "B", "C", "D", "E"};
  8. 	private int dim;
  9. 	private Node2[] head;
  10.  
  11. 	public Graph2(int DIM, String path) {
  12. 		dim = DIM;
  13. 		head = new Node2[dim];
  14. 		for (int i = 0; i < dim; i++)
  15. 			head[i] = new Node2(labels[i]);
  16.  
  17. 		loadFromFile(path);
  18.  
  19. 	}
  20.  
  21. 	private void loadFromFile(String path)
  22. 	{
  23. 		File f = new File(path);
  24. 		int val = 0;
  25. 		try {
  26. 			Scanner input = new Scanner(f);
  27. 			for (int i = 0; i < dim; i++)
  28. 			{
  29. 				for (int j = 0; j < dim; j++) 
  30. 				{
  31. 					val = input.nextInt();
  32. 					if (val == 1)
  33. 					{
  34. 						Node2 n = new Node2(labels[j]);
  35. 						head[i].addNode(n);
  36. 					}
  37. 				}
  38. 			}
  39. 			input.close();
  40.  
  41.  
  42. 		} catch (FileNotFoundException e) {
  43. 			// TODO Auto-generated catch block
  44. 			e.printStackTrace();
  45. 		}
  46. 	}
  47.  
  48. 	public void print()
  49. 	{
  50. 		for (int i = 0; i < dim; i++) {
  51. 			System.out.print(head[i].getNodeID() + " -> ");
  52. 			Iterator<Node2> iterator = head[i].getListOfNodes().iterator();
  53. 			while(iterator.hasNext())
  54. 			{
  55. 				System.out.print(iterator.next().getNodeID() + " -> ");
  56. 			}
  57.  
  58. 			System.out.println("NULL");
  59. 		}
  60. 	}
  61. }

Implementazione della classe Principale. 

  1. import java.util.Scanner;
  2.  
  3. public class Principale {
  4. 	public static void main(String[] args) {
  5. 		Graph2 g2 = new Graph2(5, "graph.txt");
  6. 		g2.print();		
  7. 	}
  8. }

Metodo 3

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

  1. import java.io.File;
  2. import java.io.FileNotFoundException;
  3. import java.util.ArrayList;
  4. import java.util.HashMap;
  5. import java.util.Iterator;
  6. import java.util.LinkedList;
  7. import java.util.Map;
  8. import java.util.Scanner;
  9.  
  10. public class Graph4 {
  11. 	private final String[] labels = {"A", "B", "C", "D", "E"};
  12. 	private int dim;
  13. 	private HashMap<String, LinkedList<String>> heads;
  14.  
  15. 	public Graph4(int DIM, String path) {
  16. 		dim = DIM;
  17. 		heads = new HashMap<String, LinkedList<String>>();
  18. 		for (int i = 0; i < dim; i++)
  19. 		{
  20. 			heads.putIfAbsent(labels[i], new LinkedList<String>());
  21. 		}
  22.  
  23. 		loadFromFile(path);
  24.  
  25. 	}
  26.  
  27. 	private void loadFromFile(String path)
  28. 	{
  29. 		File f = new File(path);
  30. 		int val = 0;
  31. 		try {
  32. 			Scanner input = new Scanner(f);
  33. 			for (int i = 0; i < dim; i++)
  34. 			{
  35. 				for (int j = 0; j < dim; j++) 
  36. 				{
  37. 					val = input.nextInt();
  38. 					if (val == 1)
  39. 					{
  40. 						heads.get(labels[i]).add(labels[j]);
  41. 					}
  42. 				}
  43. 			}
  44. 			input.close();
  45.  
  46.  
  47. 		} catch (FileNotFoundException e) {
  48. 			// TODO Auto-generated catch block
  49. 			e.printStackTrace();
  50. 		}
  51. 	}
  52.  
  53. 	public void print()
  54. 	{
  55. 		for (int i = 0; i < dim; i++) {
  56. 			System.out.print(labels[i] + " -> ");
  57. 			Iterator<String> iterator = heads.get(labels[i]).iterator();
  58. 			while(iterator.hasNext())
  59. 			{
  60. 				System.out.print(iterator.next() + " -> ");
  61. 			}
  62. 			System.out.println("NULL");
  63. 		}
  64. 	}
  65.  
  66. 	public String[] getNodeLabels() {
  67. 		return labels;
  68. 	}
  69.  
  70. 	public String[] getNextNodes(int startIDX, String[] labels) 
  71. 	{
  72. 		ArrayList<String> nextNodes = new ArrayList<String>();
  73. 		Iterator<String> iterator = heads.get(labels[startIDX]).iterator();
  74. 		while(iterator.hasNext())
  75. 		{
  76. 			nextNodes.add(iterator.next());
  77. 		}
  78.  
  79. 		String[] nextLabels = new String[nextNodes.size()];
  80. 		for (int i = 0; i < nextNodes.size(); i++)
  81. 			nextLabels[i] = nextNodes.get(i);
  82. 		return nextLabels;
  83. 	}
  84. }

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. 

  1. import java.util.Scanner;
  2.  
  3. public class Principale {
  4.  
  5. 	public static void main(String[] args) {
  6. 		Graph4 g4 = new Graph4(5, "graph.txt");
  7. 		g4.print();
  8. 		System.out.println(//////////////////////);
  9.  
  10. 		// Try Navigate
  11. 		// Inserisci il nodo di partenza
  12. 		Scanner input = new Scanner(System.in);
  13. 		String[] availableLabels = g4.getNodeLabels();
  14.  
  15. 		System.out.print("Inserisci nodo di partenza: ");
  16. 		for (int i = 0; i < availableLabels.length; i++)
  17. 			System.out.print(i + " per nodo " + availableLabels[i] + "; ");
  18. 		int node = input.nextInt();
  19. 		availableLabels = g4.getNextNodes(node, availableLabels);
  20.  
  21. 		while(availableLabels.length > 0)
  22. 		{
  23. 			for (int i = 0; i < availableLabels.length; i++)
  24. 				System.out.print(i + " per nodo " + availableLabels[i] + "; ");
  25. 			node = input.nextInt();
  26. 			if (node == -1)
  27. 				break;
  28. 			availableLabels = g4.getNextNodes(node, availableLabels);
  29. 		}
  30.  
  31. 		if (node == -1)
  32. 			System.out.println("Hai scelto di terminare il percorso !");
  33. 		else
  34. 			System.out.println("Hai raggiunto un nodo terminale");
  35.  
  36. 		input.close();	
  37. 	}
  38. }

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. 

  1. import java.io.File;
  2. import java.io.FileNotFoundException;
  3. import java.io.IOException;
  4. import java.io.PrintWriter;
  5. import java.io.RandomAccessFile;
  6. import java.util.Iterator;
  7. import java.util.LinkedList;
  8. import java.util.Scanner;
  9.  
  10. public class FileGenerator {
  11. 	public void generateGraphFile() {
  12. 		try {
  13. 			RandomAccessFile raf = new RandomAccessFile("dati.dat",  "rw");
  14. 			System.out.println("Inserisci Dimensione: ");
  15. 			Scanner input = new Scanner(System.in);
  16. 			int dim = input.nextInt();
  17. 			raf.writeInt(dim);
  18. 			for (int i = 0; i < dim; i++) {
  19. 				for (int j = 0; j < dim; j++)
  20. 				{
  21. 					System.out.print("Inserisci costo per andare da " + (char)('A'+i) + " a " + (char)('A'+j) + ": ");
  22. 					raf.writeInt(input.nextInt());
  23. 				}
  24. 			}
  25. 			//input.close();
  26. 			raf.close();
  27. 		} catch (FileNotFoundException e) {
  28. 			// TODO Auto-generated catch block
  29. 			e.printStackTrace();
  30. 		} catch (IOException e) {
  31. 			// TODO Auto-generated catch block
  32. 			e.printStackTrace();
  33. 		}
  34. 	}
  35.  
  36. 	public void savePathToFile(LinkedList<Character> percorso, int costo) 
  37. 	{
  38. 		try {
  39. 			PrintWriter output = new PrintWriter(new File("output.txt"));
  40. 			Iterator<Character> listIterator = percorso.iterator();
  41. 			while (listIterator.hasNext())
  42. 			{
  43. 				output.print(listIterator.next() + " -> ");
  44. 			}
  45. 			output.println("END");
  46.  
  47. 			output.println("Costo del percorso: " + costo);
  48. 			output.close();
  49.  
  50. 		} catch (FileNotFoundException e) {
  51. 			// TODO Auto-generated catch block
  52. 			e.printStackTrace();
  53. 		}
  54. 	}
  55. }

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

  1. import java.io.FileNotFoundException;
  2. import java.io.IOException;
  3. import java.io.RandomAccessFile;
  4. import java.util.ArrayList;
  5.  
  6. public class Graph {
  7. 	private int dim;
  8. 	private int[][] matrix;
  9.  
  10. 	public Graph(String path) {
  11. 		try {
  12. 			RandomAccessFile inputFile = new RandomAccessFile(path, "r");
  13. 			inputFile.seek(0);
  14. 			dim = inputFile.readInt();
  15. 			matrix = new int[dim][dim];
  16. 			for (int i = 0; i < dim; i++) {
  17. 				for (int j = 0; j < dim; j++) {
  18. 					matrix[i][j] = inputFile.readInt();
  19. 				}
  20. 			}
  21. 			inputFile.close();
  22.  
  23. 		} catch (FileNotFoundException e) {
  24. 			// TODO Auto-generated catch block
  25. 			e.printStackTrace();
  26. 		} catch (IOException e) {
  27. 			// TODO Auto-generated catch block
  28. 			e.printStackTrace();
  29. 		}
  30. 	}
  31.  
  32. 	public void printGraph() 
  33. 	{
  34. 		System.out.println("/////////////////");
  35. 		System.out.println("Graph");
  36. 		for (int i = 0; i < dim; i++)
  37. 			System.out.print((char)('A'+i) + "\t");
  38. 		System.out.println();
  39. 		for (int i = 0; i < dim; i++) {
  40. 			for (int j = 0; j < dim; j++) {
  41. 				System.out.print(matrix[i][j] + "\t");
  42. 			}
  43. 			System.out.println();
  44. 		}
  45. 	}
  46.  
  47. 	public int getDim()
  48. 	{
  49. 		return dim;
  50. 	}
  51.  
  52. 	public ArrayList<Integer> getNextNodes(int node) 
  53. 	{
  54. 		ArrayList<Integer> temp = new ArrayList<Integer>();
  55. 		for (int i = 0; i < dim; i++)
  56. 		{
  57. 			if (matrix[node][i] > 0)
  58. 				temp.add(i);
  59. 		}
  60.  
  61. 		return temp;
  62. 	}
  63.  
  64. 	public int getCosto(int i, int j)
  65. 	{
  66. 		return matrix[i][j];
  67. 	}
  68. }

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

  1. import java.util.ArrayList;
  2. import java.util.LinkedList;
  3. import java.util.Scanner;
  4.  
  5. public class Principale {
  6. 	public static void main(String[] args) {
  7. 		long startTime = System.currentTimeMillis();
  8. 		FileGenerator fg = new FileGenerator();
  9. 		//fg.generateGraphFile();
  10. 		Graph g = new Graph("dati.dat");
  11. 		g.printGraph();
  12. 		System.out.println(System.currentTimeMillis() - startTime);
  13.  
  14. 		///////////////////////////////////////
  15. 		// Try Navigate
  16. 		// Inserisci il nodo di partenza
  17. 		Scanner input = new Scanner(System.in);
  18. 		LinkedList<Character> percorso = new LinkedList<Character>();
  19.  
  20. 		ArrayList<Integer> nextNodes = new ArrayList<Integer>();
  21. 		int costo = 0;
  22. 		System.out.print("Inserisci nodo di partenza: ");
  23. 		for (int i = 0; i < g.getDim(); i++)
  24. 			System.out.print(i + " per nodo " + (char)('A'+i) + "; ");
  25.  
  26. 		int node = input.nextInt();
  27. 		percorso.add(((char)('A'+node)));
  28. 		nextNodes = g.getNextNodes(node);
  29. 		System.out.println("Sei sul nodo: " + (char)('A'+node));
  30.  
  31. 		while(nextNodes.size() > 0)
  32. 		{
  33. 			for (int i = 0; i < nextNodes.size(); i++)
  34. 				System.out.print(i + " per nodo " + (char)('A'+nextNodes.get(i)) + "; ");
  35. 			int temp = node;
  36. 			node = input.nextInt();
  37. 			if (node == -1)
  38. 				break;
  39. 			percorso.add(((char)('A'+node)));
  40. 			costo = costo + g.getCosto(temp, nextNodes.get(node));
  41. 			System.out.println("Sei sul nodo: " + (char)('A'+nextNodes.get(node)));
  42. 			nextNodes = g.getNextNodes(node);
  43. 		}
  44.  
  45. 		if (node == -1)
  46. 			System.out.println("Hai scelto di terminare il percorso !");
  47. 		else
  48. 			System.out.println("Hai raggiunto un nodo terminale");
  49. 		System.out.println("Costo del percorso effettuato: " + costo);
  50.  
  51. 		input.close(); 
  52.  
  53. 		fg.savePathToFile(percorso, costo);
  54. 	}
  55. }
Estratto da "http://www.vitoantoniobevilacqua.it/wiki/index.php?title=Esercitazione_JAVA_2019&oldid=971"