Esercitazione JAVA 2019

Da Bioingegneria Elettronica e Informatica.


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. }
Estratto da "http://www.vitoantoniobevilacqua.it/wiki/index.php?title=Esercitazione_JAVA_2019&oldid=955"