Ingresso e uscita in Java

1. Ingresso e uscita in Java F. Bombi 14 ottobre 2003

2. I flussi di ingresso e uscita • Il pacchetto java.io definisce le operazioni di ingresso e uscita in termini di flussi (stream). • I flussi sono sequenze ordinate di dati che hanno una sorgente (flussi di ingresso) o una destinazione (flussi di uscita) • Le classi di java.io nascondono i dettagli del sistema operativo sottostante e dei dispositivi di ingresso e uscita coinvolti dalle operazioni di ingresso e uscita

3. Caratteri e byte • I flussi di ingresso e uscita possono essere • flussi di caratteri (character stream) composti da caratteri Unicode codificati con 16 bit, le classi che realizzano i flussi di caratteri sono indicate come • lettori (reader) • scrittori (writer) • flussi di byte (byte stream) composti da byte di 8 bit, le classi che realizzano i flussi di byte sono indicate come • flussi di ingresso (input stream) • flussi di uscita (output stream)

4. Byte e Caratteri • Si utilizzeranno byte stream quando si voglia elaborare informazione di tipo binario oppure quando si voglia elaborare, un carattere alla volta, file composti da caratteri rappresentati con un solo byte ciascuno secondo la codifica ASCII • Si utilizzeranno reader e writer quando si voglia elaborare informazione di tipo testuale. È possibile convertire uno stream in un reader o in writer in modo che un testo Unicode sia trasformato in un flusso di byte un carattere per byte e viceversa

5. Errori • È sempre possibile che un’operazione di ingresso o uscita non vada a buon fine. Ad esempio si può cercare di aprire un file che non esiste oppure cercare di scrivere su di un file protetto in scrittura o leggere un file protetto in lettura. • Gli errori di ingresso e uscita sono segnalati in due modi: in qualche caso l’errore è segnalato cambiando lo stato dello stream, più frequentemente l’errore è segnalato lanciando un’eccezione di tipo IOException che deve essere catturata o passata al programma chiamante

6. Ingresso da file binari • Per leggere un file in formato binario si utilizza un oggetto della classe FileInputStream • Un file di cui si conosca il nome come stringa di caratteri si apre invocando il costruttore: FileInputStream in = new FileInputStream(nome); • Per leggere un byte si utilizza il metodo read() che restituisce un int con il byte letto inserito negli 8 bit meno significativi • All’EOF il metodo read() restituisce il valore –1 • Al termine delle operazioni di ingresso il file deve essere chiuso invocando il metodo close()

7. Uscita su file binari • Per scrivere un file in formato binario si utilizza un oggetto della classe FileOutputStream • Il file in uscita viene aperto invocando il costruttore: FileOutputStream out = new FileOutputStream(nome);che crea il file individuato dalla stringa nome se non esiste o azzera il file se esiste • Per scrivere un byte si utilizza il metodo write(int c). Il metodo usa un solo parametro int del quale verranno trasferiti in usciti gli 8 bit meno significativi • Al termine delle operazioni di uscita il file deve essere chiuso, per assicurarsi che il contenuto dei buffer di sistema sia effettivamente trasferito sul file, invocando il metodo close()

8. arg(0) arg(1) $ java Copia2 f1 f2 // Copia2.java import java.io.*; public class Copia2 { public static void main (String[] arg) throws IOException { FileInputStream in = new FileInputStream(”pippo”); FileOutputStream out = new FileOutputStream(”pluto”); int c = in.read(); while (c != -1) { out.write(c); c = in.read(); } out.close(); in.close(); } }

9. Lettore o Reader • Per accedere ad un file di testo si userà un reader aprendo il file con il costruttore: FileReader lettore = new FileReader(nome); • Il lettore consente di leggere un carattere alla volta con il metodo read(), è in genere più comodo leggere una riga alla volta convertendo il lettore in un BufferedReader con il costruttore: BufferedReader in = new BufferedReader(lettore); • Il BufferedReader dispone del metodo readLine() che restituisce in una stringa un’intera riga letta dal file (privata del fineriga) • All’EOF il metodo realLine() restituisce un riferimento null

10. Scrittore o Writer • Per scrivere un file di testo si userà un writer aprendo il file con il costruttore: FileWriter scrittore = new FileWriter(nome); • Lo scrittore consente di scrivere un carattere alla volta con il metodo write(c), è in genere più comodo disporre delle funzionalità di un PrintWriter creato con il costruttore: PrintWriter out = new PrintWriter(scrittore); • Il PrintWriter dispone dei metodi print(arg) e println(arg) che convertono l’argomento in una stringa per poi trasferirla in uscita eventualmente con l’aggiunta di un fineriga

11. Che cosa è il fineriga? • Un file di testo è un file composto da caratteri (nel nostro caso da caratteri di un byte secondo la codifica ASCII) • Il file è diviso in righe cioè in sequenze di caratteri terminati dalla stringa fineriga • Il fineriga dipende dal sistema operativo • “\r\n” Windows • “\n” Unix – Linux • “\r” MAC OS • L’uso di un BufferedReader e del metodo readLine() in ingresso, di un PrintWriter e del metodo println() in uscita, consentono di ignorare il problema della dipendenza del fineriga dall’ambiente in cui un’applicazione è utilizzata • Se si elabora un file di testo un carattere alla volta è necessario gestire le differenze fra i diversi ambienti, in particolare il fatto che in due casi la stringa fineriga è di un carattere e nell’altro e composta da due caratteri

12. Che cosa è l’End Of File (EOF) • La fine di un file (EOF) corrisponde alla fine dei dati che compongono il file • L’EOF non è un carattere contenuto nel file! • La condizione di EOF viene segnalata quando si cerca di leggere un byte o un carattere dopo la fine fisica del file • Per segnalare la fine di un file da tastiera si usa una sequenza di controllo • Ctr z Windows • Ctr d Unix

13. import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; public class Copia3 { public static void main (String[] arg) throws IOException { FileReader in = new FileReader(”pippo”); FileWriter out = new FileWriter(”pluto”); int c = 0; while ((c = in.read()) != -1) out.write(c); out.close(); in.close(); } } NB: è un errore cercare di copiare un file binario con questo programma

14. Flussi standard • La macchina virtuale Java eredita dal sistema operativo tre flussi già aperti che vengono passati al metodo main(): • System.in ingresso standard di tipo InputStream normalmente connesso alla tastiera del posto di lavoro • System.out uscita standard di tipo PrintStream normalmente connesso con la finestra di lavoro • System.err uscita standard per i messaggi d’errore di tipo PrintStream normalmente connesso con la finestra di lavoro • Ingresso e uscite standard dovrebbero essere dei reader e dei writer, sono stati definiti come stream nella versione 1.0 di JDK prima dell’introduzione dei flussi di caratteri nel pacchetto java.io. L’uso della classe PrintStream è deprecated (tollerato per compatibilità all’indietro) e in pratica usato solo con System.out e System.err.

15. Dirottamento dei flussi standard • La shell Unix e analogamente il prompt di comandi Windows consentono di dirottare (operazione di file redirection) l’ingresso e l’uscita standard rispettivamente dalla tastiera ad un file e dallo schermo verso un file • È poi possibile trasformare l’ingresso standard in un InputStreamReader e successivamente in un BufferedReader. In questo modo è possibile leggere dall’ingresso una riga alla volta con il metodo readLine() molto più comodo del metodo read() che richiede di leggere un carattere alla volta e di gestire il fineriga (diverso da sistema a sistema)

16. Flussi standard public class Eco { public static void main (String[] v) { System.out.println(v.length); for (int i = 0; i < v.length; i++) System.out.print(v[i] + ", "); System.out.println(); } } Parametri della riga di comando < schermo Tastiera System.in System.out applicazione > System.err file file schermo

17. BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); Copia.java import java.io.*; public class Copia { public static void main (String[] arg) throws IOException {InputStreamReader lettore = new InputStreamReader(System.in); BufferedReader in = new BufferedReader(lettore); String str = in.readLine(); while (str != null) { System.out.println(str); str = in.readLine(); } } } • $ java Copia • $ java Copia >nomeFile • $ java Copia <nomeFile • $ java Copia <f1 >f2

18. // Crea.java import java.io.*; public class Crea { public static void main (String[] arg) throws IOException { FileOutputStream out = new FileOutputStream(arg[0]); int n = Integer.parseInt(arg[1]); for (int i = 0; i < n; i++) out.write(i); out.close(); } } $ java Crea file lunghezza

19. // Dump.java -- esamina il contenuto di un file binario import java.io.*; public class Dump { public static void main (String[] arg) throws IOException { FileInputStream in = new FileInputStream(arg[0]); int n = Integer.parseInt(arg[1]); int c = 0; int i = 0; String str = Integer.toString(i); while (str.length() < 4) str = " " + str; System.out.print(str); String car = " "; while (((c = in.read()) != -1) && (i < n)) { str = Integer.toString(c); while (str.length() < 4) str = " " + str; System.out.print(str); i++; if (c < 31) car += '.'; // i caratteri di controllo diventano un punto else if (c < 128) car += (char)c; // caratteri ASCII else car += '*'; // eventuali caratteri > 127 diventano * segue

20. segue if (i % 10 == 0) // ogni 10 caratteri un fineriga { System.out.println(car); car = " "; str = Integer.toString(i); while (str.length() < 4) str = " " + str; System.out.print(str); } } } } 0 47 47 32 68 117 109 112 46 106 97 // Dump.ja 10 118 97 32 45 45 32 101 115 97 109 va -- esam 20 105 110 97 32 105 108 32 99 111 110 ina il con 30 116 101 110 117 116 111 32 100 105 32 tenuto di 40 117 110 32 102 105 0 0 1 2 3 4 5 6 7 8 9 .......... 10 10 11 12 13 14 15 16 17 18 19 .......... 20 20 21 22 23 24 25 26 27 28 29 .......... 30 30 31 32 33 34 35 36 37 38 39 .. !"#$%&' 40 40 41 42 43 44 45 46 47 48 49 ()*+,-./01