Scarica Programmazione Concorrente e Distribuita: Input/Output in Java - Prof. Coen Porisini e più Appunti in PDF di Elementi di Informatica solo su Docsity!
Programmazione concorrente e distribuita
Input / Output in java
Ad ogni programma in esecuzione sono associati 1 canale di input e 2 canali di output:
- System.in --> Lo standard input, da cui si legge un byte alla volta;
- System.out --> Lo standard output, sul quale si possono scrivere delle stringhe;
- System.err --> Lo standard error, sul quale si possono scrivere delle stringhe; Nota bene Lo standard output viene usato per comunicare all'ambiente le informazioni normalmmete prodotte dal programma. Lo standard error viene usato per comunicare all'ambiente le informazioni relative agli errori occorsi durante l'eecuzione del programma. Il modo più semplice per stampare su standard output delle stringhe è medinate il metodo println Es.
- System.out.println("Prova");
Il package java.io
Il package java.io include classi, interfacce ed eccezzioni per la gestione I/O. Distinguiamo tra due famiglie di funzionalità:
- Funzionalità per accedere ad informazioni relative ai file ed alle directory (dimensioni file, elenco file ecc.);
- Funzionalità per leggere e scrivere dati (Socket); Nota Per la programmazione distribuita utiliziamo le funzionalità per leggere e scrivere dati.
Classi per l'accesso al file system
La classe fondamentale per accedere alle informazioni relative ai file ed alle directory è la classe File. è fondamentale tenere presenti i problemi di portabilità del codice, perchè si presentano in maniera differente:
- Path ;
- Percorso di un file ; Nota Entrambi differiscono sostanzialmente in base al sistema operativo che viene preso in esame.
costruire
- public File (File parent, String child) : Dando un oggetto file che rappresenta una directory seguito dal file che si vuole realizzare
La classe File: metodi principali
- public String getName()
- public String getPath()
- public String getParent()
- public boolean exists() : Controlla l'esistenza di un file;
- public boolean canRead()
- public boolean canWrite()
- public boolean canExecute()
- public boolean createNewFile() : Il contenuto del file vecchio viene azzerato, qualore esista;
- public boolean delete() : Cancella il contenuto del file; Nota In grassetto quelli utili, tutti i metodi ritornano un valore booleano che indica se l'operazione è andata a buon fine.
Lettura e scrittura di dati
Distinguiamo tra:
- Accesso sequenziale (un elemento alla volta): Non sono limitate ai file, sono le classi da utilizzare nella programmazione distribuita;
- Classi per l'accesso diretto a dati contenuti su file;
Classi per la lettura e la scrittura seqeunziale di dati
Il meccanismo di lettura e scrittura sequenziale dei dati è basato sul concetto di stream. uno stream è un oggetto sul quale è possibile leggere e scrivere dati sequenzialmente. Il package java.io include numerose classi per la gestione di stream.
- Stream di byte (leggo il singolo byte, sequenza di 8 bit): ◦ inputStream ; ◦ outputStream ;
- Stream di caratteri (leggo un carattere,, che è sempre un byte ma interpretato come carattere 'r','s') : ◦ Reader ; ◦ Writer ;
La classe InputStream
Classe astratta che racchiude tutti i metodi per la lettura da uno stream di byte. è la radice di una gerarchia di classi usate per leggere gli stream di byte. Metodi principali:
Le sottoclassi di InputStream
le principali sottoclassi sono:
- FileInputStream : Per leggere uno stream da un file
- FilterInputStream : Superclasse di tutte le classi specifiche (fanno cose in più), tra cui: ◦ BufferedInputStream: che sfrutta un buffer interno per ottimizzare; ◦ DataInputStream : Per leggere i tipi base di java, valori interi, booleani, char ecc. (interpreta i byte in funzione del tipo associato);
- ObjectInputStream : Per leggere gli oggetti;
La classe DataInputStream
Fornisce metodi per leggere i diversi tipi base del linguaggio java da un InputStream esistente. Sfrutta lo standard UniCode per leggere i dati in maniera indipendente dalla piattaforma. Principali metodi: readBoolean, readByte, readInteger, readShort, readLong, readFloat, readDouble, readChar, readUnsignedByte, readUnsignedShort Di solito si leggono dati scritti con metodi della classe DataoutputStream.
La classe OutputStream
Classe astratta che racchiude tutti i metodi per la scrittura di uno stream di byte. è la radice di una gerarchia di classi. Metodi principali:
- public void write(byte b[]): Scrivo in un vettore di byte;
- public void write(byte b[], int off, int len) : Prendo un vettore e due valori che indicano da dove partire a scrivere e uanti byte devo scrivere;
- public void close() : Chiude lo stream;
- public void flush() : Svuota lo stream (Ci sono casi in cui sono presenti buffer interni non visibili);
Le sottoclassi di OutputStream
le principali sottoclassi sono:
- FileOutputStream : Per scrivere uno stream in un file;
- FilteroutputStream : Superclasse di tutte le classi specificate, tra cui: ◦ BufferedoutputStream : Sfrutta un buffer interno per ottimizzare; ◦ DataOutputStream : Per scrivere i tipi base di Java;
- ObjectOutputStream : Per scrivere oggetti;
La sottoclasse DataOutputStream
Fornisce metodi per scrivere i diversi tipi base del linguaggio Java su un OutputStream esistente.
Scrivi
import java.io.*; //il package io import java.util.Random; //Per generare //numeri casuali public class Scrivi { private static final int MAX = 100; //genera numeri casuali interi tra 0 e 100 public static void main(String[] args) throws IOException { // 1. Verifica presenza argomento if(args.length != 1) { System.err.println("Uso: scrivi "); System.exit(-1); } //2. Verifica che il file non sia esistente File f = new File(args[0]); if (f.exists()) { System.err.println("Il file " + args[0] + " esiste"); System.err.println("Lo sovrascrivo!"); f.delete(err); } //3. Crea il file f.createNewFile(); // 4. Apre un DataOutputStream associato al file DataOutputStream dOut = new DataOutputStream( new FileOutputStream(f)); //5. Genera un numero casuale, lo stampa su stdout e // lo scrive nel file per 10 volte Random rG = new Random(); int num; for(int i=1; i<11; i++) { num = rG.nextInt(MAX); System.out.println("Generato numero casuale "+ i +
". Si tratta di " + num); dOut.writeInt(num); } //6. Chiude lo stream dOut.close(); } }
Leggi: Il programma che legge
- Verifica la presenza dell'argomento: gli argomenti sono nel vettore di sringhe args[], parametro del main;
- Verifica che il file sia presente;
- Apre un DataInptStream associato al file;
- Legge un numero dallo stream lo stampa e lo somma fino a che non incontra EOF (end of File);
- Stampa su stout la somma;
- Chiude lo stream;
Leggi
import java.io.*; //il package di io public class Leggi { public static void main(String[] args) throws IOException { // 1. Verifica presenza argomento if(args.length != 1) { System.err.println("Uso: leggi "); System.exit(-1); } // 2. Verifica che il file sia esistente
◦ Chiede la connessione;
Scrivi: Il programma che scrive [Client]
- Istanzia un InetAddress associato alla macchina host;
- Instanzia un Socket per comunicare con l'host sulla porta port;
- Apre un DataOutputStream associato al Socket;
- genera un numero casuale, lo stampa su stdout e lo scrive nel Socket 10 volte;
- Chiude lo stream e il socket;
Scrivi
import java.io.; //il package io import java.util.Random; //Per generare numeri casuali import java.net.; public class ScriviSocket { private static final int MAX = 100; private static final String host = "localhost"; public static void main(String[] args) throws IOException, InterruptedException { // 1. Istanzia InetAddress InetAddress addr = InetAddress.getByName(host); // 2. Istanzia Socket Socket s = new Socket(addr, LeggiSocket.port); // 3. Apre il DataOutput Stream DataOutputStream dOut = new DataOutputStream(s.getOutputStream()); //4. Genera un numero casuale, lo stampa // su stdout e lo scrive sul Socket per 10 volte Random rG = new Random(); for(int i=1; i<11; i++) {
int num = rG.nextInt(MAX); System.out.println("Generato numero casuale "+ i + ". Si tratta di " + num); dOut.writeInt(num); } //5. Chiude lo stream e il socket dOut.close(); s.close(); } }
Leggi: Il programma che legge
- Istanzia il ServerSocket: Si predispongono all'ascolto su una determinata porta;
- Si pone all'ascolto e quando arriva una richiesta crea l'oggetto Socket;
- Apre il DatainputStream associato al Socket da cui leggere;
- legge un numero dallo stream, lo stampa e lo somma funo a che non incontra EOS;
- Stampa su stdout la somma;
- Chiude lo stream, il Socket e il ServerSocket;
Leggi
import java.io.; //il package di io import java.net.; //il package di rete public class LeggiSocket { public static final int port = 10001; public static void main(String[] args) throws IOException { // 1. Istanzia il ServeSocket ServerSocket server = new ServerSocket(port); try {
caratteri.
La classe Reader
Classe astratta che racchiude tutti i metodi per la lettura di uno stream di caratterti. Metodi principali:
- public int read(char c[]): Bloccante; ritorna - 1 se si è raggiunta la fine dello stream;
- public int read(char c[], int off, int len) : Bloccante; ritorna - 1 se si è raggiunta la fine dello stream;
- public void close();
- public long skip(long n);
La classe InputStreamreader
Costituisce il ponte tra gli stream di byte e quelli di caratterit. Effettua la conversione da byte a caratteri in maniera dipendente dal particolare "encoding" adottato. Costruttore principale:
- Public InputStreamreader(IntputSetram is)
La classe FileReader
Usata per l'accesso seqeunziale a file di caratteri. Ridefinsice i metodi della classe InputStreamReader fornendo una implemnetazione specifica per i file di caratterti.
Costruttori:
- public FileReader(String name)
- public FileReader(File f)
- public FileReader(FileDescriptor fd)
La classe Filterreader
Si tratta della superclasse di tutet le classi che forniscono funzionalità di filtro su stream di caratteri. Si appoggia ad un Reader esistente. Fornisce tutti i metodi della classe reader.
La classe BufferedReader
Sfritta un buffer interno per ottimizzare la lettura. Si appoggia d un reader esistente. Fornisce prestazioni decisamente superiori al classico Reader. Metodi aggiunti:
- public String readLine() : Per leggere una linea alla volta;
La classe Writer
Classe astratta che racchiude tutti i metodi per la scrittura in uno stream di caratteri.
- public FileWriter(String name);
- public FileWriter(File f);
- public FileWriter(FileDescriptor fd); la classe PrintWriter Permette la stampa di tutti i tipi base di Java come stringhe:
- Metodo println;
- è la classe di System.out. di System.err; Per assicurarsi che scriva correttamente:
- void flush();
- PrintWriter (Writer, true);
Esempio di uso di Reader e Writer
Un programma che legge un file di testo e stampa a video solo le linee contenenti una certa stringa passata come parametro (grep).
- Verifica che il programma sia stato invocato con due argomento (File e Stringa);
- Verifica che il primo argomento corrisponde al file esistente;
- Istanzia un BufferedReader;
- Legge una linea alla volta e confronta il contenuto con il secondo argomento A. Se il contenuto della linea allora stampa la linea, altrimenti non la stampa;
- Al termine chiudo il Bufferedreader;
Esempio
import java.io.*; public class grep { public static void main(String[] args) throws IOException { // 1. verifica gli argomenti if(args.length != 2) { System.err.println("Uso: grep "); System.exit(-1); } // 2. verifica che il primo argomento sia un file File f = new File(args[0]); if (!f.exists()) { System.err.println("Il file " + args[0] + " non esiste"); System.exit(-1); } // 3. Istanzia un BufferedReader BufferedReader br = new BufferedReader( new FileReader(f)); // 4. Legge una linea alla volta while(br.ready()) { //leggo fino a che c'è qualcosa da leggere String str = br.readLine(); if (str.contains(args[1])) System.out.println(str); } // Chiude il BufferedReader br.close(); } }
Reader e Writer distribuiti
