Flussi, lettori e scrittori

Transcript

Flussi, lettori e scrittori
Per sequenze di byte, InputStream,
OutputStream e loro sottoclassi.

Es:
InputStream in = …;
int next = in. read();
if (next != -1)
byte b = (byte) next;
Per sequenze di caratteri, Reader, Writer e
loro sottoclassi

Es:
Reader reader = …;
int next = reader. read();
if (next != -1)
char c = (char) next;
Operazioni di I/O con i File
Leggere e scrivere sequenze di byte da file
su disco: FileInputStream e FileOutputStream

FileInputStream in = new
FileInputStream(“input.dat”);
Leggere dati di testo da un file su disco:
FileReader e FileWriter

FileReader reader = new FileReader (“input.txt”);
File di Testo
La classe BufferedReader con readline()

FileReader reader = new FileReader(“inp.txt”);
BufferedReader in = new BufferedReader(reader);
String inputLine = in.readLine();
double x = Double.parseDouble(inputLine);
La classe PrintWriter

print e println
Alla fine:

reader.close()
o, per un oggetto writer della classe PrintWriter,
writer.close()
La gerarchia
delle eccezioni
• Eccezioni controllate
• Eccezioni non controllate
Esempio: una classe di prodotti
import java.io.BufferedReader;
import java.io.EOFException;
import java.io.IOException;
public class Product
{ public Product() {...}
public Product(String aName, double aPrice, int aScore) {...}
public boolean read(BufferedReader in) throws IOException {...}
public String getName() {...}
public double getPrice() {...}
public int getScore() {...}
public void setPrice(double newPrice) {...}
private String name;
private double price;
private int score;
}
Esempio:
leggere prodotti da un file di testo
public boolean read (BufferedReader in) throws IOException
{ name = in.readLine(); // legge il nome del prodotto
if (name == null) return false;
String inputLine = in.readLine(); // legge il prezzo del prodotto
if (inputLine == null)
throw new EOFException ("EOF durante la lettura del prezzo");
price = Double.parseDouble(inputLine);
// legge il punteggio del prodotto
inputLine = in.readLine();
if (inputLine == null)
throw new EOFException ("EOF durante la lettura del
punteggio");
score = Integer.parseInt(inputLine);
return true; }
Esempio prodotti: gestire le eccezioni
public void openFile()
{
BufferedReader in = null;
try
{…
// mostra la finestra di dialogo di scelta del file
in = new BufferedReader (new FileReader(selectedFile));
readProducts(in);
}
catch(FileNotFoundException e)
{
JOptionPane.showMessageDialog
(null, "Nome del file errato. Prova di nuovo."); }
catch(IOException e)
{
(null, "File alterato. Prova di nuovo.");}
finally
{
if (in != null)
try { in.close(); }
{
(null, "Errore nella chiusura del file.");} }
}
Esempio prodotti: gestire le eccezioni
public void readProducts(BufferedReader in) throws IOException
{
boolean done = false;
while (!done)
{
Product p = new Product();
if (p.read(in))
panel.addProduct(p);
else // ha letto ultimo prodotto
done = true;
}
}
Accesso sequenziale e accesso casuale
Accesso sequenziale
Record a dimensione variabile
e a dimensione fissa
Programma Database.java
import java.io.IOException;
import java.io.RandomAccessFile;
public class Database
{ public static void main(String[] args)
{ ConsoleReader console = new ConsoleReader(System.in);
System.out.println
(“Inserire il nome del file di dati:");
String filename = console.readLine();
try
{ RandomAccessFile file
= new RandomAccessFile(filename, "rw");
long nrecord = file.length() / RECORD_SIZE;
boolean done = false;
while (!done)
{ System.out.println
(“Indicare il record da aggiornare (1 - "
+ nrecord + "), nuovo record (0), uscire (-1)");
int pos = console.readInt();
if (1 <= pos && pos <= nrecord) // aggiorna il record
{ file.seek((pos - 1) * RECORD_SIZE);
Product p = readProduct(file);
System.out.println(“Trovato ” + p.getName()
+ ” ” + p.getPrice() + ” ” + p.getScore());
System.out.println
(“Immettere il nuovo prezzo:");
double newPrice = console.readDouble();
p.setPrice(newPrice);
file.seek((pos - 1) * RECORD_SIZE);
writeProduct(file, p);
}
else if (pos == 0) // aggiunge un record
{ System.out.println(“Immettere il nuovo prodotto:");
String name = console.readLine();
System.out.println(“Immettere il prezzo:");
double price = console.readDouble();
System.out.println(“Immettere il punteggio:");
int score = console.readInt();
Product p = new Product(name, price, score);
file.seek(nrecord * RECORD_SIZE);
writeProduct(file, p);
nrecord++;
}
else if (pos == -1)
done = true;
}
file.close();
}
{ System.out.println(“Eccezione Input/Output ” + e);
}
}
/**
Legge una stringa di lunghezza fissa.
@param f il file dal quale leggere
@param size il numero di caratteri da leggere
@return la stringa alla quale sono stati tolti gli spazi eccedenti
*/
public static String readFixedString(RandomAccessFile f,
int size) throws IOException
{ String b = “";
for (int i = 0; i < size; i++)
b += f.readChar();
return b.trim();
}
/**
Scrive una stringa di lunghezza fissa.
@param f il file sul quale scrivere
@param size il numero di caratteri da scrivere
*/
public static void writeFixedString(RandomAccessFile f,
String s, int size) throws IOException
{ if (s.length() <= size)
{ f.writeChars(s);
for (int i = s.length(); i < size; i++)
f.writeChar(’ ');
}
else
f.writeChars(s.substring(0, size));
}
/**
Legge un record di un prodotto.
@param f il file dal quale leggere
@return il prodotto successivo memorizzato nel file.
*/
public static Product readProduct(RandomAccessFile
{
f)
throws IOException
String name = readFixedString(f, NAME_SIZE);
double price = f.readDouble();
int score = f.readInt();
return new Product(name, price, score);
}
/**
Scrive un record di un prodotto.
@param f il file sul quale scrivere
*/
public static void writeProduct(RandomAccessFile f,
Product p) throws IOException
{ writeFixedString(f, p.getName(), NAME_SIZE);
f.writeDouble(p.getPrice());
f.writeInt(p.getScore());
}
public static final int NAME_SIZE = 30;
public static final int CHAR_SIZE = 2;
public static final int INT_SIZE = 4;
public static final int DOUBLE_SIZE = 8;
public static final int RECORD_SIZE
= CHAR_SIZE * NAME_SIZE + DOUBLE_SIZE + INT_SIZE;
}
File di database relazionali
Flussi di Oggetti
Per scrivere e leggere oggetti possiamo
scomporli nelle loro parti elementari e
scrivere e leggere queste parti, ma...
In Java c’è una soluzione più semplice:
le classi ObjectOutputStream e
ObjectInputStream
In un solo colpo scriviamo o leggiamo
interi oggetti!
L’Interfaccia Serializable
public class Razionale implements Serializable, ...
{ ... }
....
Razionale r = new Razionale(3,5);
ObjectOutputStream out =
new ObjectOutputStream (new FileOutputStream(“dati.dat”));
out.writeObject (r);
o, ancora meglio...
Possiamo scrivere (o leggere) in un solo colpo
intere collezioni di oggetti:
Vector v = new Vector();
String s = Console.readString();
Razionale r = Razionale.parseRaz(s);
v.add(r);
ObjectOutputStream out =
new ObjectOutputStream (new FileOutputStream(“dati.dat”));
out.writeObject (v);