7. Array e Collection 8. Progetto di classi 9. Ereditarietà 10. Eccezioni 11. Stream 5. Definire metodi 6. Strutture di controllo.

Transcript

1 Modulo di Roadmap 0. Primi passi con Java 1. Buone abitudini 2. Tipi di dati primitivi 3. Uso di classi 4. Leggere e scrivere 7. Array e Collection 8. Progetto di classi 9. Ereditarietà 10. Eccezioni 11. Stream 5. Definire metodi 6. Strutture di controllo Input/Output I programmi visti finora acquisiscono i loro input solo da tastiera e producono i loro output solo a video Qualunque programma di uso pratico deve salvare i suoi dati in modo permanente ed essere in grado di recuperarli successivamente I meccanismi di input/output seguono uno schema comune indipendente dal dispositivo utilizzato Stream 1

2 Modulo di Stream Interazione con dispositivi esterni: tastiera, video, dischi, schede di rete Su ciascun dispositivo sono possibili operazioni di lettura (input) e/o scrittura (output) Viste dal programmatore le operazioni possono essere astratte dal dispositivo utilizzato e riferite genericamente a flussi (stream)) di dati Gli stream Idea: classi base che forniscono operazioni elementari di lettura e scrittura a livello di byte (formato binario) o di caratteri (formato testuale) Non si usano direttamente ma sono la base sulla quale i meccanismi di I/O più articolati si appoggiano per eredità Meccanismo "a cipolla": bisogna creare una serie di oggetti in cascata prima di arrivare ad ottenere qualcosa di utile Stream 2

3 Modulo di Un errore di design?! Le gerarchie derivate dalle classi base rispondono in realtà a due esigenze diverse: gestire diversi dispositivi e offrire diverse forme di I/O (modi di accesso, formattazione, ) I due tipi di esigenze sono stati fusi e ne è nata una struttura confusa e incoerente Le evoluzioni hanno peggiorato le cose: gerarchie parallele e incrociate La libreria di I/O di Java è indicata da alcuni come un ottimo esempio di come NON fare OO design L'albero dell'i/o (non tutto) File Object ObjectStreamClass FileDescriptor ObjectStreamField RandomAccessFile StreamTokenizer InputStream OutputStream ByteArrayInputStream PipedInputStream ByteArrayOutputStream StringBufferInputStream SequenceInputStream FileOutputStream PipedOutputStream FileInputStream FilterInputStream ObjectInputStream FilterOutputStream ObjectOutputStream BufferedOutputStream DataOutputStream PrintStream BufferedInputStream DataInputStream Reader Writer PrintWriter CharArrayReader PipedReader CharArrayWriter PipedWriter BufferedReader StringReader BufferedWriter StringWriter FilterReader InputStreamReader FilterWriter OutputStreamWriter FileReader FileWriter Stream 3

4 Modulo di Definizioni di interface nel package java.io ObjectInputValidation ObjectStreamConstants Flushable Closeable FileFilter FilenameFilter DataInput DataOutput Serializable ObjectInput ObjectOutput Externalizable Idee di base Uno stream di input si crea, si effettuano letture, si chiude Uno stream di output si crea, si effettuano scritture, si chiude Gli stream elementari sono molto grezzi: di norma è meglio associare loro un "filtro" che permette operazioni di più alto livello Le operazioni di lettura e scrittura si fanno quindi sul filtro che le trasforma in operazioni sul flusso elementare associato Stream 4

5 Modulo di Gli stream di input e output elementari Le classi InputStream e OutputStream sono astratte: uno stream elementare è un'istanza di una loro sottoclasse Alcune sottoclassi identificano grosso modo il tipo di flusso di dati coinvolto: ByteArray = buffer in memoria File Pipe StringBuffer: Deprecated! Le classi filtro L'associazione tra uno stream ed il filtro avviene tramite il costruttore Data*Stream Stream: : permettono di leggere/scrivere da uno stream di byte direttamente in variabili di tipo elementare Buffered*Stream Stream: : aggiungono capacità di buffering ad un input/output stream PrintStream: : permette di ottenere output formattato visualizzabile (ha i metodi print e println: : System.out è un PrintStream) Stream 5

6 Modulo di Ricapitolando Ogni stream è caratterizzato come input o come output (può effettuare operazioni solo in una direzione) I file vengono tipicamente riscritti da capo (con la maggior parte degli output stream non è possibile aggiungere dati ad un file esistente: bisogna riscriverli) Di norma si costruisce uno stream elementare con dei filtri aggiuntivi per renderlo praticamente utilizzabile (gli stream elementari operano un byte alla volta) Lo stream viene associato ad un file su disco tramite un istanza della classe File Roadmap 11. Stream La classe file Stream 6

7 Modulo di La classe File Malgrado il suo nome, la classe File serve a rappresentare solo i nomi dei file Fornisce un modo di riferire un file per nome e di effettuare operazioni sull intero file (p.e. cancellarlo o rinominarlo) ma non sul suo contenuto (non offre metodi di lettura e scrittura dei dati) Per operare sui dati di un file con un certo nome bisogna creare un istanza della classe File che lo rappresenta e quindi associarla ad uno stream La classe File La classe File permette l'uso di pathname completi e fornisce le operazioni base su file e directory Tre costruttori: new File(String nomefileodir); new File(String path, String name); new File(File dir, String name); L'operazione new File non crea un nuovo file o directory nel file system ma solo un oggetto che permette di far riferimento ad un file o directory tramite il nome Stream 7

8 Modulo di createnewfile(); delete(); deleteonexit(); exists(); Metodi della classe File isabsolute(); isdirectory(); isfile(); ishidden(); list(); listfiles(); mkdir(); mkdirs(); renameto(); setlastmodified(); setreadonly(); canread(); canwrite(); getcanonicalpath(); getabsolutepath(); getcanonicalfile(); getabsolutefile(); (); Roadmap 11. Stream La classe file Stream binari Stream 8

9 Modulo di Stream e file binari In modo molto improprio si parla di file (e relativi stream) ) binari per indicare file nei quali sono salvati tipi di dati elementari nel loro formato di rappresentazione interna (p.e. un double è salvato come 8 byte, un int come 4 byte, ecc.) Le classi DataInputStream e DataOutputStream vengono usate per operare su stream binari Esse offrono metodi per leggere e scrivere tipi di dati elementari (p.e. readdouble, writedouble,, ) Creazione a cipolla File f = new File("/tmp tmp/nome. /nome.ext"); Si crea l istanza della classe File riferita ad un certo nome FileInputStream i = new FileInputStream(f); Si crea un istanza di input stream elementare associata al file BufferedInputStream b = new BufferedInputStream(i); Si crea un istanza di filtro di buffering associata allo stream elementare DataInputStream d = new DataInputStream(b); Si associa infine a tutto ciò un istanza di filtro di stream binario int k = d.readint readint(); Su tale istanza è possibile invocare i metodi di lettura di tipi elementari Stream 9

10 Modulo di Creazione compatta Normalmente si scrive la sequenza di costruzione di oggetti in modo compatto (la cipolla risulta più evidente) DataInputStream d = new DataInputStream( new BufferedInputStream( new FileInputStream( new File("/tmp tmp/nome. /nome.ext")))); Esempio uso di un file binario import java.io.*; import necessari: saranno sempre sottintesi import java.util util.*; negli esempi successivi public class Cipolla { private static void esistenza (File f) { if (f.exists exists()) System.out.println println("il FILE ESISTE ED E' DI DIMENSIONE " + f.length length() +" BYTES"); else System.out.println println("il FILE NON ESISTE"); } Stream 10

11 Modulo di Esempio uso di un file binario public static void main (String [] args) throws IOException, FileNotFoundException I metodi utilizzati scagliano { File f = new File("prova.dat dat"); eccezioni checked: poiché esistenza(f); non le gestiamo dobbiamo Creiamo il file e verifichiamo se esiste dichiararle con throws FileOutputStream s = new FileOutputStream(f); BufferedOutputStream b = new BufferedOutputStream(s); DataOutputStream d = new DataOutputStream(b); Creazione cipolla di output (forma estesa) for (int i = 0; i < 5; i ++) d.writeint writeint(myutil.leggiintero( Inserire un intero )); Scriviamo nel file 5 int d.close close(); Chiudiamo lo stream letti da tastiera esistenza(f); Vediamo cosa è cambiato Esempio uso di un file binario DataInputStream c = new DataInputStream(new BufferedInputStream(new FileInputStream(f))); Creazione cipolla di input (forma estesa) Vector<Integer Integer> > letture = new Vector<Integer Integer>(); Preparazione di un Vector dove mettere le letture boolean finito = false; while (! finito) { try{ { letture.add add(c. (c.readint());} catch (EOFException( e) { finito = true; ; } } for (int i : letture) System.out.println println(i); } //main }// class Si leggono int dal file e si mettono nel Vector, fino a quando un eccezione ci dice che siamo arrivati alla fine del file Infine mostriamo a video cosa abbiamo letto dal file Stream 11

12 Modulo di Roadmap 11. Stream La classe file Stream binari Stream di testo Stream e file di testo Gli stream delle gerarchie collegate a InputStream e OutputStream trattano stream binari e tipi elementari Il contenuto di tali file non è leggibile dagli utenti umani (almeno non comodamente): se si apre un file binario con un editor il contenuto non è intelligibile Inoltre tali file sono utilizzabili da altri programmi solo se essi adottano la stessa rappresentazione interna dei dati Gli stream e file di testo contengono solo sequenze di caratteri e superano tali limitazioni Stream 12

13 Modulo di Stream e file di testo I file di testo contengono solo caratteri rappresentati secondo standard universalmente adottati: sono intellegibili e apribili con qualunque editor possono essere utilizzati (in quanto file di testo) da altri programmi Per contro la rappresentazione come testo dei numeri ha degli svantaggi: occupa più spazio (per numeri di molte cifre) per trattare i numeri come numeri bisogna convertirli dalla rappresentazione testuale a quella numerica Stream di testo Per gli stream di testo si fa riferimento alle classi Reader e Writer che forniscono le primitive per scrivere un carattere alla volta Si applica quindi il solito meccanismo a cipolla Stream 13

14 Modulo di Scrittura su file di testo La classe PrintWriter offre la possibilità di invocare metodi print e println per la stampa di qualunque oggetto (si stampa il risultato dell invocazione di tostring() sull oggetto) File f = new File ("/tmp tmp/textfile.txt"); PrintWriter pw = new PrintWriter ( new BufferedWriter( new FileWriter ( f ))); Solo 1.5: output con printf A partire dalla versione 1.5 nella classe PrintWriter e disponibile la primitiva printf per la scrittura su file, in modo del tutto analogo a quanto già visto per la scrittura a video Stream 14

15 Modulo di Lettura da file di testo Non esiste metodo di lettura universale Si leggono stringhe e poi si converte usando metodi appositi (per i tipi elementari sono nelle classi wrapper) File f = new File ("/tmp tmp/textfile.txt"); BufferedReader source = new BufferedReader( new FileReader(f)); String rigaletta = source.readline readline(); int j = Integer.parseInt parseint(rigaletta); Solo 1.5: input con Scanner E possibile creare un istanza di Scanner associata ad uno stream di lettura di testo Questo permette di leggere e convertire simultaneamente la rappresentazione testuale di un numero usando metodi quali nextint(), nextdouble(), ecc. analogamente a quanto già visto per le letture da tastiera Stream 15

16 Modulo di Esempio di uso di file di testo public class CipollaTxtStringhe {... // METODO esistenza() public static void main (String [] args) throws IOException, FileNotFoundException { File f = new File("fileStringhe filestringhe.txt"); esistenza(f); Creazione cipolla PrintWriter PrintWriter pw = new PrintWriter(new BufferedWriter( new FileWriter ( f ))); String s =""; do { s = MyUtil.leggiString leggistring("inserire UNA STRINGA"); if (! s.equalsignorecase equalsignorecase("fine")) Ciclo di lettura stringhe da pw.println println(s); tastiera e loro scrittura su file } while (! s.equalsignorecase equalsignorecase("fine")); pw.close close(); Chiusura dello stream Esempio di uso di file di testo esistenza(f); Vediamo cosa è cambiato BufferedReader source = new BufferedReader( new FileReader(f)); Vector<String String> > elenco = new Vector<String String>(); do { s = source.readline readline(); if (! (s == null)) elenco.add add(new String(s)); } while (! (s == null)); Creazione cipolla Ciclo di lettura righe da file Quando si raggiunge la fine del file la lettura restituisce null source.close close(); Chiusura dello stream for (String letta : elenco) System.out.println println(letta); } //main }// class Stream 16

17 Modulo di Esempio di uso di file di testo con Scanner public class CipollaTxtNumeri {... // METODO esistenza() public static void main (String [] args) throws IOException, FileNotFoundException { File f = new File("fileNumeri filenumeri.txt"); esistenza(f); Creazione cipolla PrintWriter PrintWriter pw = new PrintWriter(new BufferedWriter( new FileWriter ( f ))); Ciclo di lettura 5 numeri da for (int i = 0; i < 5; i ++) tastiera e loro scrittura su file pw.println println(myutil.leggiintero("inserire UN NUMERO")); pw.close close(); Chiusura dello stream esistenza(f); Esempio di uso di file di testo con Scanner Scanner source = new Scanner(new FileReader(f)); Vector<Integer Integer> > elenco = new Vector<Integer Integer>(); Ciclo di lettura righe da file: il while (source.hasnextint()) metodo hasnextint ci dice se ci { sono ancora valori da leggere. elenco.add add(source.nextint()); Non si controlla se il file è vuoto o } corrotto source.close close(); Chiusura dello stream for (int letto : elenco) System.out.println println(letto); } //main }// class Vediamo cosa è cambiato Creazione Scanner Stream 17

18 Modulo di Conversione tra stream E' possibile trasformare uno stream di byte in uno stream di testo tramite le classi di conversione InputStreamReader e OutputStreamWriter Aumenta il numero di strati della cipolla BufferedReader r = new BufferedReader( new InputStreamReader( new DataInputStream( new BufferedInputStream( new FileInputStream( new File("/tmp tmp/nome. /nome.ext")))))); Pre 1.5: Lettura input da tastiera La tastiera è associata all'inputstream System.in: si applica la cipolla anche qui (versioni precedenti alla 1.5) BufferedReader keyboard = new BufferedReader( new InputStreamReader(System.in)); String rigaletta = keyboard.readline readline(); int j = Integer.parseInt parseint(rigaletta); Stream 18

19 Modulo di Input con Scanner Come già sappiamo, la classe Scanner permette di acquisire valori da un InputStream (in particolare la tastiera) in modo molto più comodo Scanner input = new Scanner(System.in); String s = input.next next(); int c = input.nextint nextint();... input.close close(); Solo 1.5: input con Scanner La classe Scanner oltre che su stream (e file) può operare su String e su interface Readable Essa permette anche usi sofisticati come l effettuazione di ricerche e la separazione di elementi usando le cosiddette espressioni regolari Si veda la documentazione della classe per questi aspetti sofisticati Stream 19

20 Modulo di Roadmap 11. Stream La classe file Stream binari Stream di testo Stream di oggetti Stream e file di oggetti Tipicamente un programma Java rappresenta i suoi dati più importanti come oggetti (istanze di classi) anche collegati tra loro (p.e. un Vector è un istanza che contiene istanze di oggetti, ciascuna delle quali può avere come attributi istanze di altre classi, ecc. Emerge la necessità di salvare su file direttamente gli oggetti Quando si salva su file un oggetto si vuole che siano salvati in un colpo solo anche gli oggetti collegati In modo duale si vuole leggere in un colpo solo un oggetto salvato insieme a tutti quelli collegati Stream 20

21 Modulo di Stream di oggetti Java offre un modo comodo per salvare e leggere oggetti e loro collegati (con struttura arbitrariamente complessa) Gli Object*Stream (in formato binario) lo permettono tramite i metodi writeobject e readobject Il metodo di lettura restituisce un riferimento ad un oggetto generico (Object( Object) ) è richiesto quindi un cast esplicito per riattribuire all oggetto il suo tipo originario Per poter essere usata con gli Object*Stream una classe DEVE dichiarare implements Serializable (interface speciale, nessun metodo da implementare) Esempio uso stream di oggetti: salvare un array public class CipollaObj {...// METODO esistenza() public static void main (String [] args) throws IOException, FileNotFoundException, ClassNotFoundException { Creazione cipolla File f = new File("obj obj.dat"); ObjectOutputStream esistenza(f); ObjectOutputStream archivio = new ObjectOutputStream( new BufferedOutputStream( new FileOutputStream(f))); int [] a = new int [20]; for (int i = 0; i < a.length length; ; i ++) a[i] = i*2; archivio.writeobject writeobject(a); archivio.close close(); Le eccezioni da dichiarare sono aumentate Creazione e riempimento di un array di prova L array viene salvato in un colpo solo Chiusura dello stream Stream 21

22 Modulo di esistenza(f); } // main }//class Esempio stream di oggetti Vediamo cosa è cambiato ObjectInputStream sorgente = new ObjectInputStream( new BufferedInputStream( new FileInputStream(f))); try { E necessario il cast a = (int( []) sorgente.readobject readobject(); for i = 0; i < a.length length; ; i ++) System.out.println println(a[i]); } catch (ClassCastException( exc) {System.out.println Creazione cipolla ObjectInputStream L array viene letto in un colpo solo Controlliamo che nel file sia stato trovato quello che ci si aspettava println("grave errore di tipo in lettura!");} finally {if (sorgente!= null) ) sorgente.close close();} In ogni caso lo stream va chiuso Il numero di versione Ad ogni classe che implementa l interface Serializable viene implicitamente e automaticamente aggiunto un attributo di tipo long denominato serialversionuid Questo attributo rappresenta il numero di versione della classe e viene memorizzato al momento della scrittura delle sue istanze tramite writeobject Stream 22

23 Modulo di Il numero di versione Ogni volta che il codice sorgente della classe cambia (anche minimamente) cambia anche il valore di serialversionuid Se si tenta di leggere da un file degli oggetti salvati con numero di serie precedente a quello attuale si genera un eccezione Questo può essere scomodo e sgradevole quando le modifiche apportate alla classe sono davvero minimali e non danno luogo ad effettiva incompatibilità tra gli oggetti salvati e la nuova versione della classe Il numero di versione Il programmatore può decidere, sotto la sua responsabilità, di definire esplicitamente l attributo serialversionuid che deve essere final static long e preferibilmente private Eclipse segnala con un warning la possibilità di definire esplicitamente l attributo serialversionuid quando si implementa l interface Serializable Stream 23

24 Modulo di Il numero di versione Se l attributo serialversionuid viene definito esplicitamente, sarà il programmatore a dover cambiare il valore dell attributo a fronte di modifiche significative del codice Se il programmatore non cura questo aspetto, ci saranno comportamenti imprevisti (anche subdoli) o eccezioni a seguito del caricamento di oggetti salvati incompatibili con la nuova versione della classe Roadmap 11. Stream La classe file Stream binari Stream di testo Stream di oggetti File ad accesso diretto Stream 24

25 Modulo di File ad accesso diretto I file ad accesso diretto sono realizzati tramite la classe RandomAccessFile che (stranamente) è isolata nella gerarchia La classe RandomAccessFile implementa le interfacce DataInput e DataOutput che sono le stesse dei Data*Stream e offrono operazioni di lettura e scrittura per i tipi elementari L'accesso diretto è realizzato tramite un indice (file pointer) a livello di byte: il calcolo del numero dei byte appropriato è a carico del programmatore Operazioni: getfilepointer(), seek(byteoffset byteoffset) File ad accesso diretto L'accesso diretto è vantaggioso rispetto all'accesso sequenziale che obbliga a lente scansioni lineari dei file Purtroppo l'accesso diretto fornito dalla classe RandomAccessFile e' scomodissimo: si possono leggere e scrivere solo tipi elementari (nemmeno stringhe) e bisogna fare i conti in byte delle posizioni dei dati Stream 25

26 Modulo di Roadmap 11. Stream La classe file Stream binari Stream di testo Stream di oggetti File ad accesso diretto Stream con compressione Compressione dati Classi Zip*Stream e GZIP*Stream supportano l'attività di compressione/decompressione negli stream (nel package java.util util.zip) I costruttori hanno come parametro un Input/OutputStream al quale aggiungono la compressione /decompressione (solita cipolla) BufferedReader r = new BufferedReader( new InputStreamReader( new GZIPInputStream( new FileInputStream( new File("/tmp tmp/nome. /nome.gz"))))); Stream 26

27 Modulo di Compressione dati La classe Zip*Stream supporta la presenza di più entries entro un unico stream compresso In pratica si possono creare i comuni archivi zip contenenti più file con i metodi putnextentry, getnextentry Esempio uso file zip import java.io.*; import java.util util.zip.*; public class CipollaZipObj {...// METODO esistenza() C è un import specifico per stream zip public static void main (String [] args) throws IOException, FileNotFoundException, ClassNotFoundException { File f = new File("obj obj.zip"); esistenza(f); Bisogna creare un primo pezzo di cipolla ZipOutputStream zipout = new ZipOutputStream( new BufferedOutputStream( new FileOutputStream(f))); zipout.putnextentry putnextentry(new ZipEntry("file. ("file.dat")); Aggiungere il nome del file interno zippato da creare ObjectOutputStream archivio = new ObjectOutputStream(zipOut zipout); Infine aggiungere lo strato di ObjectOutputStream Stream 27

28 Modulo di Esempio uso file zip int [] a = new int [20000]; for (int i = 0; i < a.length length; ; i ++) a[i] = i*2; archivio.writeobject writeobject(a); archivio.close close(); esistenza(f); ZipInputStream zipin = new ZipInputStream( new BufferedInputStream( new FileInputStream(f))); zipin.getnextentry getnextentry(); Creazione e riempimento di un array di prova L array viene salvato in un colpo solo Chiusura dello stream Bisogna creare un primo pezzo di cipolla Selezionare il file interno zippato da cui leggere ObjectInputStream sorgente = new ObjectInputStream(zipIn zipin); Infine aggiungere lo strato di ObjectInputStream Esempio uso file zip try { a = (int( []) sorgente.readobject readobject(); for (int i = 0; i < a.length length; ; i+=1000) System.out.println println(a[i]); } catch (ClassCastException( exc) {System.out.println println("grave errore di tipo in lettura!");} finally {if (sorgente!= null) ) sorgente.close close();} } // main }//class Il seguito del programma è immutato ma visto che sono stampiamo un numero ogni 1000 Stream 28