C. Horstmann Fondamenti di programmazione e Java 2 3^ edizione Apogeo

Transcript

1 File e Flussi C. Horstmann Fondamenti di programmazione e Java 2 3^ edizione Apogeo trad. Nicola Fanizzi corso di Programmazione, CdS: Informatica TPS Dip. di Informatica, Università degli studi di Bari

2 Obiettivi 2 Saper leggere e scrivere file di testo Acquisire familiarità con i concetti di formato binario e di testo Capire la codifica cifrata delle informazioni Capire quando va usato l accesso casuale o sequenziale ai file Saper leggere e scrivere oggetti usando la serializzazione

3 Leggere e Scrivere File di Testo 3 Il modo più semplice per leggere file di testo prevede l utilizzo della classe Scanner Per leggere dati da un file presente sul disco, occorre dapprima costruire un oggetto di tipo FileReader FileReader reader = new FileReader("input.txt"); Scanner in = new Scanner(reader); Si utilizza tale oggetto come parametro per costruire un oggetto di tipo Scanner Per leggere i dati, si possono usare i metodi della classe: next, nextline, nextint e nextdouble

4 Leggere e Scrivere File di Testo 4 Per scrivere file di testo usate la classe PrintWriter e i suoi metodi print e println PrintWriter out = new PrintWriter("output.txt"); Se il file in cui scrivere esiste già, viene svuotato prima di scrivervi nuovi dati Se il file non esiste, viene creato un file vuoto

5 Leggere e Scrivere File di Testo 5 Usate, poi, i consueti metodi print e println per inviare numeri, oggetti e stringhe all'istanza di PrintWriter out.println(29.95); out.println(new Rectangle(5, 10, 15, 25)); out.println("hello, World!"); Quando avete terminato di scrivere in un oggetto di tipo PrintWriter,, accertatevi di chiuderlo out.close(); Se il programma termina l esecuzione senza aver chiuso l oggetto di tipo PrintWriter,, può darsi che non tutti i dati siano stati realmente scritti nel file su disco

6 Esempio di Programma 6 Legge tutte le righe presenti in un file di dati in ingresso e le invia ad un file di uscita, facendo precedere a ciascuna riga di testo il corrispondente numero di riga Se il file d ingresso è: Mary had a little lamb Whose fleece was white as snow. And everywhere that Mary went, The lamb was sure to go!

7 Esempio di programma 7 Allora il programma produce il seguente file: /* 1 */ Mary had a little lamb /* 2 */ Whose fleece was white as snow. /* 3 */ And everywhere that Mary went, /* 4 */ The lamb was sure to go! I numeri di riga sono racchiusi tra delimitatori /* */ in modo che il programma possa essere utilizzato per numerare file di codice sorgente Java

8 LineNumberer.java 8 01: import java.io.filereader; 02: import java.io.ioexception; 03: import java.io.printwriter; 04: import java.util.scanner; 05: 06: public class LineNumberer 07: { 08: public static void main(string[] args) 09: { 10: Scanner console = new Scanner(System.in); 11: System.out.print("Input file: "); 12: String inputfilename = console.next(); 13: System.out.print("Output file: "); 14: String outputfilename = console.next(); 15: 16: try 17: { 18: FileReader reader = new FileReader(inputFileName); 19: Scanner in = new Scanner(reader); 20: PrintWriter out = new PrintWriter(outputFileName); 21: int linenumber = 1;

9 LineNumberer.java 9 22: 23: while (in.hasnextline()) 24: { 25: String line = in.nextline(); 26: out.println("/* " + linenumber + " */ " + line); 27: linenumber++; 28: } 29: 30: out.close(); 31: } 32: catch (IOException exception) 33: { 34: System.out.println("Error processing file:" + exception); 35: } 36: } 37: }

10 Una Finestra di Dialogo 10 Figura 1: Una finesta di dialogo del tipo JFileChooser

11 Una Finestra di Dialogo 11 JFileChooser chooser = new JFileChooser(); FileReader in = null; if (chooser.showopendialog(null) == JFileChooser.APPROVE_OPTION) { File selectedfile = chooser.getselectedfile(); reader = new FileReader(selectedFile);... }

12 Formato di Testo 12 Esistono due modi fondamentalmente diversi di memorizzare i dati: In formato testo In formato binario

13 Formato di Testo 13 Nel formato testo i dati sono rappresentati in una forma leggibile dagli esseri umani come una sequenza di caratteri Per esempio, il numero intero viene memorizzato come una sequenza di cinque caratteri: '1' '2' '3' '4' '5' Per elaborare dati in ingresso e in uscita dovete usare le classi Reader e Writer e le loro sottoclassi Per leggere: FileReader reader = new FileReader("input.txt"); Per scrivere: FileWriter writer = new FileWriter("output.txt");

14 Formato Binario 14 Nel formato binario i dati sono rappresentati da byte In formato binario il numero intero viene registrato come una sequenza di quattro byte come una sequenza di quattro byte Se memorizzate le informazioni in forma binaria, come sequenza di byte, dovete usare le classi InputStream e OutputStream e le loro sottoclassi La memorizzazione binaria è più compatta e più efficiente

15 Formato Binario 15 Per leggere dati binari da un file su disco si crei un oggetto di tipo FileInputStream FileInputStream inputstream = new FileInputStream("input.bin"); Si usi oggetti di tipo FileWriter e FileOutputStream per scrivere dati in un file su disco in forma di testo o, rispettivamente, binaria FileOutputStream outputstream = new FileOutputStream("output.bin");

16 Leggere un Singolo Carattere da 16 un File in Formato Testo La classe Reader ha un metodo, read,, che legge un carattere alla volta Il metodo read di fatto restituisce un dato di tipo int 1 Alla fine dei dati, read restituisce 1 Reader reader =...; int next = reader.read(); char c; if (next!= -1) c = (char) next;

17 Leggere un Singolo Carattere da 17 un File in Formato Testo La classe InputStream ha un metodo read per leggere un byte alla volta Restituisce un dato di tipo int,, che può essere il byte che è stato inserito Restituisce il numero intero 1,, se è stata raggiunta la fine del flusso InputStream in =...; int next = in.read(); byte b; if (next!= -1) b = (byte) next;

18 Formato Testo e Binario 18 Le classi Writer e FileOutputStream hanno un metodo write per scrivere, rispettivamente, un singolo carattere o byte Questi metodi basilari sono gli unici metodi di lettura e scrittura forniti dalle classi che leggono e scrivono un file Il pacchetto dei flussi di Java si basa sul principio che ciascuna classe deve avere una responsabilità ben precisa

19 Formato Testo e Binario 19 Il compito di un oggetto di tipo FileInputStream è quello di interagire con i file, cioè di acquisire dati sotto forma di byte, non di analizzarli Se volete leggere numeri, stringhe o altri oggetti, dovete combinare la classe con altre classi

20 Un Programma di Crittografia 20 Il programma cifra un file Mescola i dati in modo che siano illeggibili tranne per chi conosca il metodo di decifrazione e la corrispondente parola segreta Useremo un metodo che era conosciuto ai tempi di Giulio Cesare Si sceglie una chiave di cifratura, che in questo caso è un numero compreso tra 1 e 25 Esempio se la chiave è 3, si sostituisce A con D, B con E, e così via

21 Un programma di crittografia 21 Per la decifrazione, si usa semplicemente il valore opposto della chiave (negativo) Testo normale Testo cifrato Figura 2: Il codice di Cesare

22 Elaborazione di Dati Binari 22 int next = in.read(); if (next == -1) done = true; else { byte b = (byte) next; //call the method to encrypt the byte byte c = encrypt(b); out.write(c); }

23 Encryptor.java 23 01: import java.io.file; 02: import java.io.fileinputstream; 03: import java.io.fileoutputstream; 04: import java.io.inputstream; 05: import java.io.outputstream; 06: import java.io.ioexception; 07: 08: /** 09: un cifratore cifra file usando la crittyografia di Cesare. 10: Per la decifrazione, usate un cifratore con la chiave 11: opposta a quella di cifratura. 12: */ 13: public class Encryptor 14: { 15: /** 16: Costruisce un cifratore. akey la chiave di cifratura 18: */

24 Encryptor.java 24 19: public Encryptor(int akey) 20: { 21: key = akey; 22: } 23: 24: /** 25: cifra il contenuto di un file. infile il nome del file in ingresso outfile il nome del file in uscita 28: */ 29: public void encryptfile(string infile, String outfile) 30: throws IOException 31: { 32: InputStream in = null; 33: OutputStream out = null; 34: 35: try 36: {

25 Encryptor.java 25 37: in = new FileInputStream(inFile); 38: out = new FileOutputStream(outFile); 39: encryptstream(in, out); 40: } 41: finally 42: { 43: if (in!= null) in.close(); 44: if (out!= null) out.close(); 45: } 46: } 47: 48: /** 49: Cifra il contenuto di un flusso. in il flusso di ingresso out il flusso di uscuta 52: */

26 Encryptor.java 26 53: public void encryptstream(inputstream in, OutputStream out) 54: throws IOException 55: { 56: boolean done = false; 57: while (!done) 58: { 59: int next = in.read(); 60: if (next == -1) done = true; 61: else 62: { 63: byte b = (byte) next; 64: byte c = encrypt(b); 65: out.write(c); 66: } 67: } 68: } 69:

27 Encryptor.java 27 70: /** 71: Cifra un byte. b il byte da cifrare il byte cifrato 74: */ 75: public byte encrypt(byte b) 76: { 77: return (byte) (b + key); 78: } 79: 80: private int key; 81: }

28 EncryptorTester.java 28 01: import java.io.ioexception; 02: import java.util.scanner; 03: 04: /** 05: Un programma per collaudare il cifratore con il codice di Cesare. 06: */ 07: public class EncryptorTester 08: { 09: public static void main(string[] args) 10: { 11: Scanner in = new Scanner(System.in); 12: try 13: { 14: System.out.print("Input file: "); 15: String infile = in.next(); 16: System.out.print("Output file: "); 17: String outfile = in.next();

29 EncryptorTester.java 29 18: System.out.print("Encryption key: "); 19: int key = in.nextint(); 20: Encryptor crypt = new Encryptor(key); 21: crypt.encryptfile(infile, outfile); 22: } 23: catch (IOException exception) 24: { 25: System.out.println("Error processing file: " + exception); 26: } 27: } 28: } 29: 30:

30 Crittografia con Chiave Pubblica 30 Chiave pubblica di Bob Vediamoci alla festa in toga Vediamoci alla festa in toga Testo normale Testo cifrato chiave privata di Bob testo decifrato Figura 3

31 Accesso Casuale e 31 Accesso sequenziale Accesso Sequenziale Un file viene elaborato un byte alla volta può essere poco efficiente Accesso casuale consente di accedere a posizioni arbitrarie nel file Solo i file su disco forniscono l accesso casuale System.in e System.out non lo forniscono Ciascun file su disco ha una posizione speciale detta puntatore del file Potete scrivere e leggere nella posizione in cui si trova il puntatore

32 Accesso Casuale 32 e Accesso Sequenziale Ciascun file su disco ha una posizione speciale detta puntatore del file Potete scrivere e leggere nella posizione in cui si trova il puntatore Accesso sequenziale Accesso casuale

33 RandomAccessFile 33 Potete aprire un file solo per: Leggere ( r ) Leggere e scrivere ( rw ) RandomAccessFile f = new RandomAcessFile("bank.dat","rw"); f.seek(n); L invocazione del metodo sposta il puntatore al byte di indice n, contando le posizioni dall inizio del file

34 RandomAccessFile 34 Per sapere qual è la posizione corrente del puntatore del file userete long n = f.getfilepointer(); Per sapere qual è il numero dei byte di un file si usa il metodo length filelength = f.length();

35 Esempio di Programma 35 Usa un file ad accesso casuale per memorizzare un insieme di conti correnti Il programma di prova fa specificare un numero di conto qualsiasi e vi aggiunge gli interessi Se si vuol manipolare un insieme di dati presenti in un file, si deve prestare particolare attenzione alla disposizione dei dati stessi Supposto di inserire semplicemente i dati in formato testo: Immaginiamo che il conto numero 1001 abbia un saldo uguale a $900 e che il conto numero 1015 abbia saldo 0$

36 Esempio di Programma 36 Vogliamo versare $100 nel conto numero Se ora si scrivesse semplicemente il nuovo valore, il risultato sarebbe:

37 Esempio di Programma 37 La classe RandomAccessFile memorizza i dati in binario I metodi readint e writeint leggono e scrivono numeri interi sotto forma di quantità di quattro byte double x = f.readdouble(); f.writedouble(x); I metodi readdouble e writedouble elaborano numeri in virgola mobile in doppia precisione sotto forma di quantità di otto byte

38 Esempio di Programma 38 Per poter aggiornare un file dovete assegnare a ciascun campo una dimensione fissa che sia sufficientemente grande Ne risulta che tutti i record ( insiemi di campi ) del file hanno la stessa dimensione Questo presenta il vantaggio che è molto più facile spostarsi sui record Quando si memorizzano numeri in un file avente dimensioni fisse per i record, è più facile inserirli in formato binario invece che in formato testo

39 Esempio di Programma 39 Il metodo size determina il numero totale di conti, dividendo la lunghezza del file per la dimensione di un record public int size() throws IOException { return (int) (file.length() / RECORD_SIZE); // RECORD_SIZE è pari a 12 bytes: // 4 bytes per il numero di conto e // 8 bytes per il saldo }

40 Esempio di Programma 40 Per leggere dal file il conto n-esimo, il metodo read posiziona il puntatore del file all indirizzo n * RECORD_SIZE (il primo conto ha indice n uguale a 0), quindi legge i dati e costruisce un oggetto che rappresenta un conto bancario: public BankAccount read(int n) throws IOException { file.seek(n * RECORD_SIZE); int accountnumber = file.readint(); double balance = file.readdouble(); return new BankAccount(accountNumber, balance); }

41 Esempio di Programma 41 Per scrivere un conto si fa, invece, così: public void write(int n, BankAccount account) throws IOException { file.seek(n * RECORD_SIZE); file.writeint(account.getaccountnumber()); file.writedouble(account.getbalance()); }

42 BankDatatester.java 42 01: import java.io.ioexception; 02: import java.io.randomaccessfile; 03: import java.util.scanner; 04: 05: /** 06: Questo programma collauda l accesso casuale. 07: Potete accedere ai conti esistenti e aggiungervi 08: gli interessi oppure creare nuovi conti.i conti vengono memorizzati in un file ad accesso casuale 09: */ 10: public class BankDataTester 11: { 12: public static void main(string[] args) 13: throws IOException 14: { 15: Scanner in = new Scanner(System.in); 16: BankData data = new BankData(); 17: try

43 BankDatatester.java 43 18: { 19: data.open("bank.dat"); 20: 21: boolean done = false; 22: while (!done) 23: { 24: System.out.print("Account number: "); 25: int accountnumber = in.nextint(); 26: System.out.print("Amount to deposit: "); 27: double amount = in.nextdouble(); 28: 29: int position = data.find(accountnumber); 30: BankAccount account; 31: if (position >= 0) 32: { 33: account = data.read(position); 34: account.deposit(amount); 35: System.out.println("new balance=" 36: + account.getbalance()); 37: }

44 BankDatatester.java 44 38: else // Aggiungi un nuovo conto 39: { 40: account = new BankAccount(accountNumber, 41: amount); 42: position = data.size(); 43: System.out.println("adding new account"); 44: } 45: data.write(position, account); 46: 47: System.out.print("Done? (Y/N) "); 48: String input = in.next(); 49: if (input.equalsignorecase("y")) done = true; 50: } 51: } 52: finally 53: { 54: data.close(); 55: } 56: } 57: }

45 BankData.java : import java.io.ioexception; 002: import java.io.randomaccessfile; 003: 004: /** 005: Questa classe funge da tramite per un file 006: ad accesso casuale contenente i dati di conti bancari. 007: */ 008: public class BankData 009: { 010: /** 011: Costruisce un oggetto del tipo BankData senza 012: associarlo ad un file. 013: */ 014: public BankData() 015: { 016: file = null; 017: }

46 BankData.java : 019: /** 020: Apre il file dei dati. filename il nome del file che contiene 022: informazioni sui conti bancari 023: */ 024: public void open(string filename) 025: throws IOException 026: { 027: if (file!= null) file.close(); 028: file = new RandomAccessFile(filename, "rw"); 029: } 030: 031: /** 032: Restituisce il numero di conti presenti nel file. il numero dei conti 034: */ 035: public int size() 036: throws IOException 037: { 038: return (int) (file.length() / RECORD_SIZE); 039: } 040:

47 BankData.java : /** 042: Chiude il file dei dati. 043: */ 044: public void close() 045: throws IOException 046: { 047: if (file!= null) file.close(); 048: file = null; 049: } 050: 051: /** 052: Legge il record di un nuovo conto bancario. n l indice del conto nel file dei dati conto inizializzato con i dati letti dl file 055: */ 056: public BankAccount read(int n) 057: throws IOException 058: { 059: file.seek(n * RECORD_SIZE); 060: int accountnumber = file.readint(); 061: double balance = file.readdouble(); 062: return new BankAccount(accountNumber, balance); 063: }

48 BankData.java : 065: /** 066: Trova la posizione del conto bancario avente // il numero di conto indicato accountnumber il numero di conto da cercare la posizione del conto trovato oppure 069: -1 se il non esiste conto con tale numero 070: */ 071: public int find(int accountnumber) 072: throws IOException 073: { 074: for (int i = 0; i < size(); i++) 075: { 076: file.seek(i * RECORD_SIZE); 077: int a = file.readint(); 078: if (a == accountnumber) // trovato 079: return i; 080: } 081: return -1; // Non trovato dopo aver seaminato tutti i file 082: }

49 BankData.java : 084: /** 085: Scrive nel file dei dati il record di un conto bancario n l indice del conto nel file dei dati account il conto da scrivere 088: */ 089: public void write(int n, BankAccount account) 090: throws IOException 091: { 092: file.seek(n * RECORD_SIZE); 093: file.writeint(account.getaccountnumber()); 094: file.writedouble(account.getbalance()); 095: } 096: 097: private RandomAccessFile file; 098: 099: public static final int INT_SIZE = 4; 100: public static final int DOUBLE_SIZE = 8; 101: public static final int RECORD_SIZE 102: = INT_SIZE + DOUBLE_SIZE; 103: }

50 Output 50 Account number: 1001 Amount to deposit: 100 adding new account Done? (Y/N) N Account number: 1018 Amount to deposit: 200 adding new account Done? (Y/N) N Account number: 1001 Amount to deposit: 1000 new balance= Done? (Y/N) Y

51 Flussi di Oggetti 51 La classe ObjectOutputStream può memorizzare sul disco interi oggetti La classe ObjectInputStream li può rileggere Gli oggetti vengono salvati in formato binario; di conseguenza, si usano stream e non writer

52 Scrivere in un File un Oggetto di 52 Tipo BankAccount Il flusso di uscita per oggetti memorizza automaticamente nel flusso stesso tutti i campi di esemplare dell oggetto BankAccount b =...; ObjectOutputStream out = new ObjectOutputStream( new FileOutputStream("bank.dat")); out.writeobject(b);

53 Scrivere in un File un Oggetto di 53 Tipo BankAccount Si usa il metodo readobject della classe ObjectInputStream,, che restituisce un riferimento di tipo Object Dovrete ricordare i tipi degli oggetti che avete memorizzato e usare un cast ObjectInputStream in = new ObjectInputStream(new FileInputStream("bank.dat")); BankAccount b = (BankAccount) in.readobject();

54 Scrivere in un File un Oggetto di 54 Tipo BankAccount Il metodo readobject può lanciare un eccezione di tipo ClassNotFoundException È un eccezione controllata La si cattura oppure la si dichiara in una clausola throws

55 Scrivere e Leggere un ArrayList 55 Con una sola istruzione si può salvare il vettore e tutti gli oggetti cui fa riferimento ArrayList<BankAccount> a = new ArrayList<BankAccount>(); // Ora inserisci in a molti oggetti di tipo BankAccount out.writeobject(a); E con una sola istruzione si possono rileggere tutti ArrayList<BankAccount> a = (ArrayList<BankAccount>) in.readobject();

56 Interfaccia Serializable 56 In un flusso di oggetti possono essere memorizzati soltanto esemplari di classi che realizzino l interfaccia Serializable class BankAccount implements Serializable {... } Questa interfaccia non ha metodi

57 Interfaccia Serializable 57 Il processo di memorizzazione degli oggetti in un flusso viene chiamato serializzazione Ad ogni oggetto viene assegnato un numero di serie all interno del flusso Se lo stesso oggetto viene salvato due volte, la seconda volta viene scritto soltanto il suo numero di serie Quando gli oggetti vengono poi riletti, i numeri di serie ripetuti sono considerati come riferimenti allo stesso oggetto

58 SerialTester.java 58 01: import java.io.file; 02: import java.io.ioexception; 03: import java.io.fileinputstream; 04: import java.io.fileoutputstream; 05: import java.io.objectinputstream; 06: import java.io.objectoutputstream; 07: 08: /** 09: Questo programma verifica la serializzazione di un oggetto 10: di tipo Bank. Se esiste un file con i dati serializzati di 11: una banca,esso viene caricato;altrimenti il programma parte 12: con una nuova banca. Ulteriori conti bancari sono aggiunti 13: alla banca, quindi i dati della banca vengono memorizzati nel file 14: */ 15: public class SerialTester 16: {

59 SerialTester.java 59 17: public static void main(string[] args) 18: throws IOException, ClassNotFoundException 19: { 20: Bank firstbankofjava; 21: 22: File f = new File("bank.dat"); 23: if (f.exists()) 24: { 25: ObjectInputStream in = new ObjectInputStream 26: (new FileInputStream(f)); 27: firstbankofjava = (Bank) in.readobject(); 28: in.close(); 29: } 30: else 31: { 32: firstbankofjava = new Bank(); 33: firstbankofjava.addaccount(new BankAccount(1001, 20000));

60 SerialTester.java 60 34: firstbankofjava.addaccount(new BankAccount(1015, 10000)); 35: } 36: 37: // Effettua alcuni versamenti 38: BankAccount a = firstbankofjava.find(1001); 39: a.deposit(100); 40: System.out.println(a.getAccountNumber() + ":" + a.getbalance()); 41: a = firstbankofjava.find(1015); 42: System.out.println(a.getAccountNumber() + ":" + a.getbalance()); 43: 44: ObjectOutputStream out = new ObjectOutputStream 45: (new FileOutputStream(f)); 46: out.writeobject(firstbankofjava); 47: out.close(); 48: } 49: }

61 Output 61 Prima esecuzione del programma 1001: : Seconda esecuzione del programma 1001: :