Jav@Lab Il linguaggio Java I file sequenziali

Jav@Lab Il linguaggio Java I file sequenziali

Input e Output Secondo i canoni dei linguaggi di programmazione "procedurali" il concetto di input e output è strettamente legato al tipo di dispositivo esterno di da cui e verso cui i dati transitano (dischi, nastri, ecc.): quindi il file è visto come contenitore su supporto di memorizzazione di massa, la tastiera come dispositivo di standard input e il video o la stampante assimilati a standard output. La tendenza odierna è quella di separare nettamente i dispositivi di I/O dal trattamento dei flussi di dati da e verso di essi. Per questa ragione in Java si è fatta la scelta di introdurre "astrazioni" pensate come "oggetti" che sono indipendenti dai dispositivi. Tali oggetti sono o Stream, o Pipe o Filter e sono veri e propri Abstract Data Type dotati di operazioni che non dipendono dal particolare dispositivo di I/O. Gli Stream (Flussi) Il significato letterale della parola stream è "flusso". In informatica il flusso è un astrazione che definisce i metodi di lettura/scrittura delle unità di informazione accessibili. Tali informazioni vengono anche detti "token". Un "token", quindi, è una unità di informazione accessibile è può consistere in un byte, un carattere o un oggetto strutturato. Uno stream o flusso di dati o canale è un percorso di comunicazione tra la sorgente di una certa informazione e la sua destinazione. Le sorgenti possono essere le più svariate: o la memoria Ram del computer, o Internet, o un dispositivo permanente di memorizzazione dati, o la tastiera ecc. La stessa cosa vale per le destinazioni. La sorgente e la destinazione del flusso di byte sono anche denominati rispettivamente processo produttore e processo consumatore. Sorgente = Processo Produttore Destinazione = Processo Consumatore Sorgente Flusso di Input Metodo o Programma che legge i dati Metodo o Programma che scrive i dati Flusso di Output Destinazione

Non è necessario conoscere in dettaglio la sorgente o la destinazione per leggere un flusso di input o per scrivere in un flusso di output. I metodi generali (oppure i programmi) che operano su una sorgente di dati accettano come argomento un flusso di input, così quelli che scrivono su una destinazione accettano come argomento uno stream di output. I Filters (Filtri) Oltre ai metodi (o programmi) che fanno uso di stream di I/O esistono anche "oggetti" detti processori di dati. Un filter (filtro) o processore di dato è un metodo, o un programma, dotato di due argomenti di tipo flusso: legge dati dal flusso di input, li elabora (filtra, seleziona ecc.) e li scrive sul flusso di output. I filtri non necessitano di alcuna informazione, nè riguardo alla sorgente nè riguardo alla destinazione; i filtri richiedono soltanto le modalità di accesso (astratte) al rispettivo flusso. Un filtro può essere rappresentato dalla figura: Flusso di Input FILTRO o PROCESSORE Flusso di Output La separazione delle entità Queste astrazioni:. o o o o o o Sorgente o processo produttore dei dati; Flusso di input; Pipe o condotto; Filtro o processore; Flusso di output; Destinazione o processo Consumatore dei dati consentono di separare logicamente quelle entità, come File e dispositivi di memorizzazione, che nell informatica "classica" erano considerate legate in modo univoco. È il programmatore che decide quali relazioni costruire tra le diverse entità astratte e tra queste ultime e i dispositivi concreti. I Flussi di Input/Output Le informazioni memorizzate in un file, in ultima analisi sono sempre memorizzate come serie di byte. In java un oggetto dal quale è possibile leggere una sequenza di byte viene chiamato stream di input; un oggetto sul quale è possibile scrivere una sequenza di byte viene chiamato stream di output. Tali Stream vengono specificati nelle classi astratte InputStream e OutputStream. Tali gerarchie di classi sono presenti nel package java.io. Visto che i genitori sono classi astratte, i relativi metodi sono implementati solo nelle sottoclassi della gerarchia.

Gli schemi seguenti mostrano la gerarchia, anche se non completa, delle classi essenziali relative al trattamento dei flussi di input Accesso a carattere (2 byte) InputStream ByteArrayInputStream FileInputStream OutputStream ByteArrayOutputStream FileOutputStream Accesso a byte Reader CharArrayReader StringReader InputStreamReader FileReader BufferedReader Writer CharArrayWriter StringWriter OutputStreamWriter FileWriter BufferedWriter Riflettiamo. La classe astratta InputStream ha un metodo astratto read che legge un byte e restituisce il byte letto oppure 1 in caso di non lettura. La classe FileInputStream che discende da InputStream, ridefinisce il metodo read che consente tale operazione; tale metodo permette al massimo la lettura di un gruppo di byte, ma non consente la lettura di particolari tipi di variabili. E necessario allora usare le classi Filters che elaborano i gruppi di byte letti mettendo a disposizione metodi per la lettura/scrittura di variabili di tutti i tipi fondamentali di Java. L accesso sequenziale basato sul byte Le classi FileInputStream e FileOutputStream forniscono stream di Input e Output associati ad un file del disco. Per associare uno Stream di input ad un file occorre utilizzare il costruttore della classe FileInputStream nel seguente modo: FileInputStream f = new FileInputStream( elenco.dat ); Analogamente per associare uno Stream di output ad un file è necessario utilizzare il costruttore della classe FileOutputStream nel seguente modo: FileOutputStream f = new FileOutputStream( elenco.dat ); In entrambi i casi non specificando nessun path il file verrà cercato nella directory attiva. Queste due classi poiché discendono direttamente dalle classi astratte InputStream e OutputStream possono leggere e scrivere solo byte e array di byte.

E necessario che tali flussi vengano assemblati in tipi più utili. Tale assemblaggio viene fatto da oggetti Filter, come per esempio quelli istanziati dalla classe DataInputStream e DataOutputStream, nel seguente modo: Input Output FileInputStream f = new FileInputStream ( elenco.dat ); DataInputStream in = new DataInputStream(f); FileOutputStream f = new FileOutputStream ( elenco.dat,true DataOutputStream out = new DataOutputStream(f); Le classi DataInputStream e DataOutputStream contengono tutti I metodi per la lettura e la scrittura di tutti I tipi Java: DataInputStream readboolean readbyte readchar readdouble readfloat readfully readint readline readlong readshort readutf skip.bytes DataOutputStream writechars writebyte writeint writeshort writelong writefloat writedouble writechar writeboolean writeutf Gli stream non sono bufferizzati. Questo significa che ogni chiamata di lettura o scrittura contatta il S.O. per chiedere o inviare un altro byte. Se si desidera usare un buffer è necessario usare la seguente scrittura: Input FileInputStream f = new FileInputStream ( elenco.dat ); BufferedInputStream b = new BufferedInputStream(f); Output DataInputStream in = new DataInputStream(b); FileOutputStream f = new FileOutputStream ( elenco.dat,true); BufferedOutputStream b = new BufferedOutputStream (f) DataOutputStream out = new DataOutputStream(b); DataInputStream e DataOutputStream sono sempre messi in coda perche sono tali classi ad occuparsi del filtraggio dei bytes letti. Esempio: Scrivere un programma che permetta l archiviazione di libri e la visualizzazione dell intero elenco. Per prima cosa scriviamo la classe Clibro.

package myprojects.biblioteca; import java.io.*; class CLibro implements Serializable // Attributi della classe private String Autore = ""; private String Titolo = ""; private String Edizione = ""; private String CasaEditrice = ""; private String Costo = ""; private String Anno = ""; //Costruttore vuoto public CLibro() public CLibro(String Autore,String Titolo,String Edizione,String CasaEditrice,String Costo, String Anno) this.autore = Autore; this.titolo = Titolo; this.edizione = Edizione; this.casaeditrice = CasaEditrice; this.costo = Costo;

this.anno = Anno; public void AppendiRecord(String filelibri) try //Associo un Stream al File FileOutputStream f = new FileOutputStream(fileLibri,true); //Creo un buffer associato allo stream BufferedOutputStream b = new BufferedOutputStream(f); //Inserisco un oggetto Filter per la scrittura dei tipi dei singoli attributi DataOutputStream fout = new DataOutputStream(b); //Scrivo I singoli campi fout.writeutf(autore); fout.writeutf(titolo); fout.writeutf(edizione); fout.writeutf(casaeditrice); fout.writeutf(costo); fout.writeutf(anno); //Libero il buffer fout.flush(); //Chiudo lo stream f.close(); catch(exception e)

System.out.println("Problemi di scrittura"); public void VisualizzaFile(String filelibri) try // Apro uno stream di Input FileInputStream f = new FileInputStream(fileLibri); // Associo uno stream buffer BufferedInputStream b = new BufferedInputStream(f); // Inserisco un oggetto Filter per la lettura dei singoli attributi DataInputStream fin = new DataInputStream(b); while(true) try System.out.print(fIN.readUTF()+" "); System.out.print(fIN.readUTF()+" "); System.out.print(fIN.readUTF()+" "); System.out.print(fIN.readUTF()+" "); System.out.print(fIN.readUTF()+" "); System.out.print(fIN.readUTF()+"\n"); catch(eofexception e)

break; f.close(); catch(exception e) System.out.println("Problemi di lettura"); Dopo aver scritto la classe CLIbro, scriviamo la classe Cbiblioteca package myprojects.biblioteca; import java.io.*; class CBiblioteca implements Serializable public CBiblioteca() // Metodo per la lettura da tastiera private String leggiinput() InputStreamReader input = new InputStreamReader(System.in); BufferedReader tastiera = new BufferedReader(input);

String inputstr = ""; try inputstr = tastiera.readline(); catch(exception e) System.out.println("Errore di lettura"); return(inputstr); // Metodo InserisciLibro private void InserisciLibro() System.out.print("Autore :"); String Autore = leggiinput(); System.out.print("Titolo :"); String Titolo = leggiinput(); System.out.print("Edizione :"); String Edizione = leggiinput(); System.out.print("Casa Editrice :"); String CasaEditrice = leggiinput(); System.out.print("Costo :"); String Costo = leggiinput(); System.out.print("Anno :");

String Anno = leggiinput(); CLibro libro = new CLibro(Autore,Titolo,Edizione,CasaEditrice,Costo,Anno); libro.appendirecord("libri.txt"); public void VisualizzaLibri() CLibro libro = new CLibro(); libro.visualizzafile("libri.txt"); // Metodo Main public static void main(string args[]) throws Exception int scelta = 0; System.out.println("Starting Biblioteca..."); Biblioteca b = new Biblioteca(); do System.out.println("Menu Biblioteca"); System.out.println("1. Inserisci Libro"); System.out.println("2. Visualizza Libri"); System.out.println("3. Esci"); String sceltastr = b.leggiinput(); scelta = Integer.valueOf(sceltaStr).intValue();

switch(scelta) case 1 : b.inseriscilibro(); break; case 2 : b.visualizzalibri(); break; while (scelta!= 3);