I File in Java

Da Bioingegneria Elettronica e Informatica.

Vitoantonio Bevilacqua vitoantonio.bevilacqua@poliba.it

Antonio Brunetti antonio.brunetti@poliba.it

Gianpaolo Francesco Trotta gianpaolofrancesco.trotta@poliba.it

Pagina in lavorazione

Introduzione

Java fornisce classi e metodi per scrivere e leggere dati da files; le tipologie di files che si possono trovare sono sostanzialmente due:

  • file di testo;
  • file binari.

Grazie alle classi fornite da Java, la gestione dell'input/output da file è indipendente dalla piattaforma su cui il programma verrà eseguito; inoltre, le operazioni di I/O sono basate sul concetto di flusso (stream), ovvero una sequenza ordinata di dati che ha una sorgente e una destinazione.

Per leggere dati da una sorgente bisogna collegarla a uno stream, dove leggere le informazioni in modo ordinato. Analogamente, per scrivere dati su una destinazione, bisogna collegarla a uno stream in cui inserire i dati in modo sequenziale. All’inizio di queste operazioni occorre aprire lo stream e alla fine occorre chiuderlo.


Lettura e scrittura di caratteri con file di testo

Introduzione alle classi e ai metodi per la lettura e scrittura di caratteri o byte su file.

Di seguito sono riportati due esempi che implementano I/O con i file.

Lettura da file di testo

  1. import java.io.*;
  2.  
  3. public class Principale {
  4.  
  5. 	public static void main(String[] args) {
  6. 		new Principale().run();
  7. 	}
  8.  
  9. 	public void run() {
  10. 		/* Per la lettura e scrittura di file,
  11. 		 * si utilizzano le classi di java.io:
  12. 		 * - FileReader (FileInputStream)
  13. 		 * - FileWriter (FileOutputStream)
  14. 		 * che permettono di gestire l'I/O di caratteri o bytes
  15. 		 */
  16.  
  17. 		FileReader file;
  18. 		try {
  19. 			// Lettura di file di testo con due letture successive
  20. 			file = new FileReader("dati.txt");
  21. 			int carattere = file.read();
  22. 			int carattere2 = file.read();
  23.  
  24. 			System.out.println("Il codice del carattere vale: " + carattere);
  25. 			System.out.println("Il codice del carattere vale: " + carattere2);
  26. 			file.close();
  27.  
  28. 			// Lettura di tutto il contenuto del file di testo con ciclo while
  29. 			file = new FileReader("dati.txt");
  30. 			// Letura di tutti i caratteri all'interno di un file di testo
  31. 			int next = file.read();
  32. 			while(next != -1) {
  33. 				char nextc = (char) next;
  34.                 System.out.print(nextc); // stampa il carattere
  35.                 next = file.read(); // legge il prossimo carattere
  36. 			}
  37. 			file.close();
  38.  
  39. 		} catch (IOException e) {
  40. 			// TODO Auto-generated catch block
  41. 			e.printStackTrace();
  42. 		}
  43. 	}
  44. }

Scrittura su file di testo

  1. import java.io.FileWriter;
  2. import java.io.IOException;
  3. import java.util.Scanner;
  4.  
  5. public class Principale2 {
  6.  
  7. 	public static void main(String[] args) {
  8. 		// TODO Auto-generated method stub
  9. 		new Principale2().run();
  10. 	}
  11.  
  12. 	public void run() {
  13. 		/* Per la lettura e scrittura di file,
  14. 		 * si utilizzano le classi di java.io:
  15. 		 * - FileReader (FileInputStream)
  16. 		 * - FileWriter (FileOutputStream)
  17. 		 * che permettono di gestire l'I/O di caratteri o bytes
  18. 		 */
  19.  
  20. 		FileWriter file;
  21. 		Scanner s = new Scanner(System.in);
  22. 		try {
  23. 			// Scrittura su file di testo di numeri acquisiti da tastiera
  24. 			file = new FileWriter("dati_output.txt");
  25.  
  26. 			String num = s.nextLine();
  27. 			while(!num.equals("-1")) {
  28. 				file.write(num + " ");
  29. 				num = s.nextLine();
  30. 			}
  31.  
  32. 			file.close();
  33.  
  34. 			System.out.println("Dati scritti e file chiuso");
  35.  
  36. 		} catch (IOException e) {
  37. 			e.printStackTrace();
  38. 		}
  39. 	}
  40. }

Scrittura e lettura con file binari

  1. import java.io.FileInputStream;
  2. import java.io.FileOutputStream;
  3. import java.io.IOException;
  4. import java.util.Scanner;
  5.  
  6. public class Principale3 {
  7.  
  8. 	public static void main(String[] args) {
  9. 		// TODO Auto-generated method stub
  10. 		new Principale3().run();
  11. 	}
  12.  
  13. 	public void run() {
  14. 		/* Per la lettura e scrittura di file,
  15. 		 * si utilizzano le classi di java.io:
  16. 		 * - FileReader (FileInputStream)
  17. 		 * - FileWriter (FileOutputStream)
  18. 		 * che permettono di gestire l'I/O di caratteri o bytes
  19. 		 */
  20.  
  21. 		FileOutputStream fileOutput;
  22. 		Scanner s = new Scanner(System.in);
  23. 		try {
  24. 			// Scrittura su file binario di numeri acquisiti da tastiera
  25. 			fileOutput = new FileOutputStream("dati_output.dat");
  26.  
  27. 			int num = s.nextInt();
  28. 			while(num != -1) {
  29. 				fileOutput.write(num);
  30. 				num = s.nextInt();
  31. 			}
  32.  
  33. 			fileOutput.close();
  34. 			System.out.println("Dati scritti e file chiuso");
  35.  
  36. 			FileInputStream fileInput;
  37. 			fileInput = new FileInputStream("dati_output.dat");
  38.  
  39. 			int numR = fileInput.read();
  40. 			while (numR != -1) {
  41. 				System.out.println("Il numero letto vale: " + numR);
  42. 				numR = fileInput.read();
  43. 			}
  44. 			fileInput.close();
  45. 			System.out.println("Raggiunta fine del file");
  46.  
  47. 		} catch (IOException e) {
  48. 			// TODO Auto-generated catch block
  49. 			e.printStackTrace();
  50. 		}
  51. 	}
  52. }

Lettura e scrittura bufferizzata

Lettura e Scrittura su File

Di seguito è riportato un semplice esempio per la gestione dell'input/output da file, sia di testo, sia binario. Le classi utilizzate per implementare la classe qui riportata sono: 

  1. import java.io.BufferedReader;
  2. import java.io.File;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileReader;
  5. import java.io.IOException;
  6. import java.io.InputStreamReader;
  7. import java.io.PrintWriter;
  8. import java.io.RandomAccessFile;
  9.  
  10. public class GestioneFile {
  11.  
  12. 	String textFileName = "testo.txt";
  13. 	String binaryFileName = "binario.dat";
  14.  
  15. 	public void printFile() {
  16. 		try {
  17. 			PrintWriter output = new PrintWriter(textFileName);
  18. 			output.print("Stampa su file di una stringa di testo");
  19. 			output.close();
  20. 		} catch (FileNotFoundException e) {
  21. 			// Blocco di gestione delle eccezioni
  22. 			e.printStackTrace();
  23. 		}
  24. 	}
  25.  
  26. 	public String readFromFile() {	
  27. 		String line = null;
  28. 		try {
  29. 			// Lettura di input da console
  30. 			BufferedReader console = new BufferedReader(new InputStreamReader(System.in));
  31. 			line = console.readLine();
  32. 			System.out.println(line);
  33.  
  34. 			// Lettura di input da file
  35. 			BufferedReader fileReader = new BufferedReader(new FileReader(new File(textFileName)));
  36. 			// Lettura di un singolo carattere
  37. 			char c = (char)fileReader.read();
  38. 			System.out.print(c);
  39. 			// Lettura di una riga di testo
  40. 			line = fileReader.readLine();	
  41.  
  42. 			fileReader.close();
  43. 			console.close();
  44.  
  45.  
  46. 		} catch (IOException e) {
  47. 			// Blocco di gestione delle eccezioni
  48. 			e.printStackTrace();
  49. 		}
  50. 		return line;
  51. 	}
  52.  
  53. 	public void writeBinaryFile() {
  54. 		int[] v = new int[] {1000,2,3,4,5,6,7,8,9,10};
  55. 		try {
  56. 			RandomAccessFile binaryFile = new RandomAccessFile(new File(binaryFileName), "rw");
  57. 			for (int i = 0; i < 10; i++) {
  58. 				binaryFile.writeInt(v[i]);
  59. 			}
  60. 			binaryFile.close();
  61. 		} catch (Exception e) {
  62. 			// Blocco di gestione delle eccezioni
  63. 			e.printStackTrace();
  64. 		}
  65. 	}
  66.  
  67. 	public void readBinaryFile() {
  68. 		try {
  69. 			File file = new File(binaryFileName);
  70. 			RandomAccessFile binaryFile = new RandomAccessFile(file, "r");
  71.  
  72. 			int numIntegers = (int)file.length()/4;
  73. 			int[] v = new int[numIntegers];
  74.  
  75. 			for (int i = 0; i < numIntegers; i++) {
  76. 				v[i] = binaryFile.readInt();
  77. 			}
  78.  
  79. 			binaryFile.close();
  80.  
  81. 			// Stampa il vettore acquisito
  82. 			for (int i = 0; i < numIntegers; i++) {
  83. 				System.out.print(v[i] + " ");
  84. 			}
  85. 		} catch (Exception e) {
  86. 			// Blocco di gestione delle eccezioni
  87. 			e.printStackTrace();
  88. 		}
  89. 	}
  90. }

Di seguito la classe Principale che implementa il metodo main nel quale vengono richiamate le funzioni della classe Gestione File precedentemente introdotta. 

  1. public class Principale {
  2.  
  3. 	public static void main(String[] args) { 
  4. 		GestioneFile f = new GestioneFile();
  5. 		f.printFile();
  6.  
  7. 		String l = f.readFromFile();
  8. 		System.out.println(l);
  9.  
  10. 		f.writeBinaryFile();
  11. 		f.readBinaryFile();
  12. 	}
  13. }
Estratto da "http://www.vitoantoniobevilacqua.it/wiki/index.php?title=I_File_in_Java&oldid=605"