Fluxuri de date

Tehnologii utilizate

• Tehnologii orientate pe fluxuri (Stream)

• sunt unidirecționale
• sunt sincrone
• Tehnologii orientate pe canale (Channel)
• sunt bidirectionale
• sunt asincrone
Fluxuri de citire/scriere
 Structurarea funcțională a fluxurilor

• Fluxuri de nivel scăzut (Low-level streams). Un flux de intrare sau de ieșire este conectat direct
la sursa de date (fișier, socket).
• Fluxuri de nivel înalt (High-level streams). Sunt fluxuri de intrare sau ieșire care citesc sau scriu
din/în alte fluxuri.
Fluxuri binare de intrare (citire)
 Interfața DataInput
• Conține metode dedicate citirii datelor de tip primitive și a șirurilor în format UTF
Metode de citire la nivel de byte
public void readFully(byte[] b, int off, int len) throws IOException
public void readFully(byte[] b) throws IOException

Citire șiruri
public String readLine() throws IOException
public String readUTF() throws IOException

Poziționare
public int skipBytes(int n) throws IOException
Citire primitive
public boolean readBoolean() throws IOException
public byte readByte() throws IOException
public int readUnsignedByte() throws IOException
public short readShort() throws IOException
public int readUnsignedShort() throws IOException
public char readChar() throws IOException
public int readInt() throws IOException
public long readLong() throws IOException
public float readFloat() throws IOException
public double readDouble() throws IOException
 Clasa InputStream

• Clasă abstractă care conține metode pentru funcționalitățile de bază, comune ierarhiei
• Declarația de clasă
public abstract class InputStream extends Object implements Closeable;

• Principalele metode:
public int available() throws IOException;
public void close() throws IOException;
public abstract int read() throws IOException;
public int read(byte[] b) throws IOException;
public int read(byte[] b, int off, int len) throws IOException;
public long skip(long n) throws IOException;
 Clasa FileInputStream

• Clasă care implementează funcționalitățile de bază

• Declarația de clasă:
public class FileInputStream extends InputStream;

• Constructori:
FileInputStream(String cale) throws FileNotFoundException;
FileInputStream(File fisier) throws FileNotFoundException;

• Sunt suprascrise metodele moștenite din InputStream

 Clasa DataInputStream
• Clasă care implementează citirea primitivelor și a șirurilor de caractere
• Declarația de clasă:
public class DataInputStream extends FilterInputStream implements DataInput;

• Constructori
public DataInputStream(InputStream in);

Clasa BufferedInputStream folosește un buffer intern pentru date și implementează

metodele:
public void mark(int readlimit);
public void reset() throws IOException;
Fluxuri binare de scriere
 Interfața DataOutput
• Omologul interfeței DataInput pentru scriere de primitive și a șirurilor UTF
• Scriere la nivel de byte
void write(int b) throws IOException;
void write(byte[] b) throws IOException;
void write(byte[] b, int off, int len) throws IOException;
• Scriere primitive
void writeBoolean(boolean v) throws IOException;
void writeByte(int v) throws IOException;
void writeShort(int v) throws IOException;
void writeChar(int v) throws IOException;
void writeInt(int v) throws IOException;
void writeLong(long v) throws IOException;
void writeFloat(float v) throws IOException;
void writeDouble(double v) throws IOException;
• Scriere șiruri
void writeBytes(String s) throws IOException;
void writeChars(String s) throws IOException;
void writeUTF(String s) throws IOException;
 Clasa OutputStream

• Conține principalele funcționalități pentru scriere

• Declarația de clasă:
public abstract class OutputStream extends Object implements Closeable,
Flushable;
• Metode:
public abstract void write(int b) throws IOException;
public void write(byte[] b) throws IOException;
public void write(byte[] b, int off, int len) throws IOException;
public void flush() throws IOException;
public void close() throws IOException;
 Clasa FileOutputStream

• Implementează funcționalitățile din OutputStream

• Declarația de clasă:
public class FileOutputStream extends OutputStream;

• Constructori
FileOutputStream(String cale) throws FileNotFoundException;
FileOutputStream(File fisier) throws FileNotFoundException;
public FileOutputStream(String name, boolean append) throws
FileNotFoundException;
public FileOutputStream(File file, boolean append) throws
FileNotFoundException
 Clasa DataOutputStream

• Extinde funcționalitățile de scriere la nivel de primitive și șiruri de caractere

• Declarația de clasă:
public class DataOutputStream extends FilterOutputStream
implements DataOutput;

• Constructor:
public DataOutputStream(OutputStream fluxIesire);

• Metodă specifică:
public final int size(); //Numărul de octeți scriși în fluxul de ieșire până la momentul
curent
Fluxuri caracter
 Clasa Reader
• Clasă abstractă care conține metodele de citire caractere la nivel scăzut
• Declarația de clasă:
public abstract class Reader extends Object;
• Câmpuri:
protected Object lock ; // obiect folosit in sincronizare

• Metode:
public int read() throws IOException;
public int read(char[] cbuf) throws IOException;
public abstract int read(char[] cbuf, int off, int len) throws IOException;
public boolean ready() throws IOException;
 Clasa FileReader

• Implementează funcționalitățile de baza din clasa Reader

• Declarația de clasă:
public class FileReader extends InputStreamReader;

• Constructori:
FileReader(File fis) throws FileNotFoundException;
FileReader(String fis) throws FileNotFoundException;
 Clasa BufferedReader
• Este utilizată pentru implementarea fluxurilor de nivel superior de tip caracter
• Constructori:
BufferedReader(Reader flux); //flux - este un flux de nivel scăzut care citește
caracter cu caracter
BufferedReader(Reader flux, int marime);
• Conține o metodă pentru pentru citire linii. Aceasta preia caracterele furnizate de
fluxul de nivel scăzut și pana la întâlnirea caracterelor de sfârșit de linie și
întoarce un obiect String:
String readLine() throws IOException;
 Clasa InputStreamReader
 Este un flux de legătura cu fluxurile binare. Legătura se face prin codificare. Față de
fluxurile caracter conține în plus informații de codare (UTF8, UTF16, etc.)
 Declarația de clasă:
public class InputStreamReader extends Reader;
 Metoda care întoarce tipul de codificare:
public String getEncoding();
 Constructorii primesc și un parametru de tip Charset reprezentând codificarea:
public InputStreamReader(InputStream in);
public InputStreamReader(InputStream in, String charsetName) throws
UnsupportedEncodingException;
public InputStreamReader(InputStream in, Charset cs);
public InputStreamReader(InputStream in, CharsetDecoder dec) ;
 Clasa Writer

• Clasă care stabilește operațiunile de bază ale unui flux de scriere

• Declarația de clasă:
public abstract class Writer extends Object implements Appendable, Closeable,
Flushable
• Are un mecanism de sincronizare prin obiectul monitor:
protected Object lock; // sincronizare - idem Reader
• Principalele metode:
public void write(int c) throws IOException
public void write(char[] cbuf) throws IOException
public abstract void write(char[] cbuf, int off, int len) throws IOException
public void write(String str) throws IOException
public void write(String str, int off, int len) throws IOException
public Writer append(char c) throws IOException
public Writer append(CharSequence csq, int start, int end) throws IOException
Clasa FileWriter

 Implementează funcționalitățile din Writer

 Declarația de clasă:
public class FileWriter extends Writer;
Constructori:
FileWriter(File fis) throws FileNotFoundException;
FileWriter(String fis) throws FileNotFoundException;

Clasa BufferedWriter
 Flux de nivel superior utilizat pentru scriere în fișiere text
 Constructori:
BufferedWriter(Writer flux);
BufferedWriter(Writer flux,int marime);
 Metoda de scriere linie nouă:
void newLine() throws IOException; // Inserează sfârșitul de linie
Clasa PrintWriter

 Flux de nivel superior pentru scriere date structurate in fișiere text

 Constructori:
PrintWriter(Writer flux);
PrintWriter(OutputStream flux);

 Metode:
void print(...);
void println(...);
 Clasa OutputStreamWriter

 Flux de legătură ca și InputStreamReader.

 Declarația de clasă:
public class OutputStreamWriter extends Writer;
 Codarea:
public String getEncoding(); // întoarce tipul de encodare
 Constructori:
public OutputStreamWriter(OutputStream out);
public OutputStreamWriter (OutputStream out, String charsetName) throws
UnsupportedEncodingException;
public OutputStreamWriter (OutputStream out, Charset cs);
public OutputStreamWriter (OutputStream out, CharsetDecoder dec) ;
 Serializarea

Transformarea datelor în secvențe de octeți astfel încât să poată fi transmise pe un flux de ieșire

Deserializare - procesul invers

 Scopul serializării

• transmiterea datelor la distanță. RMI

• conservarea datelor în afara timpului de execuție - persistenţa obiectelor
• asigurarea portabilității datelor sub diverse SO
• implementarea tehnologiei bazate pe componente reutilizabile - Beans
 Mecanisme de serializare

• Mecanismul implicit de serializare este realizat prin implementarea formală a

interfeței Serializable
• Serializarea voluntară se realizează in doua moduri:
• prin redefinirea metodelor readObject si writeObject. Semnătura exactă a
metodelor este:
private void readObject(java.io.ObjectInputStream stream)
throws IOException, ClassNotFoundException;
private void writeObject(java.io.ObjectOutputStream stream)
throws IOException
• prin implementarea interfeței Externalizable
 Clase si interfețe utilizate la serializarea implicită

• Interfața Serializable. Este o interfață de marcaj, fără metode abstracte, care

marchează clasele serializabile prin mecanismul implicit
• Interfața ObjectOutput extinde cadrul creat de interfața DataOutput la scrierea de
obiecte
public interface ObjectOutput extends DataOutput;
Metodă declarată pentru scriere:
void writeObject(Object obj) throws IOException; //Metoda este implementată de
clasa ObjectOutputStream
• Clasa ObjectOutputStream. Este clasa care realizează implementarea efectiva a mecanismului de serializare
• Declarația de clasa:
public class ObjectInputStream extends InputStream implements ObjectInput, ObjectStreamConstants; // in
interfața ObjectStreamConstants sunt declarate constante utilizate in mecanismul de serializare
• Constructor:
public ObjectOutputStream(OutputStream out) throws IOException; // out este un flux de scriere la nivel de
octet
• Metode
public final void writeObject(Object obj) throws IOException; // Implementează mecanismul de serializare. Sunt
exceptate de la serializare câmpurile transient. In mecanismul de serializare implicita sunt scrise clasa obiectului,
semnătura de clasa si valorile tuturor câmpurilor netransiente si nestatice. Referințele la alte obiecte
declanșează si serializarea acestora.
 Clase si interfețe utilizate la deserializarea implicita
• Interfața ObjectInput, extinde funcționalitățile din DataInput la citirea de obiecte.
public interface ObjectInput extends DataInput;
• Metoda de citire declarata:
Object readObject() throws ClassNotFoundException, IOException;
• Clasa ObjectInputStream citește obiecte serializate prin ObjectOutputStream
public class ObjectInputStream extends InputStream implements ObjectInput, ObjectStreamConstants;
• Constructor
public ObjectInputStream(InputStream in) throws IOException ; // in este flux de citire la nivel de octet
• Metoda pentru deserializare:
public final Object readObject() throws IOException, ClassNotFoundException; //sunt deserializate
obiectele serializate prin writeObject
 Serializarea voluntara prin implementarea interfeței
Externalizable

• Este o metoda utilizata pentru a personaliza procesul de serializare. Folosirea interfeței impune existența
unui constructor fără parametrii pentru clasele obiectelor serializate.
Declarația de clasă:
public interface Externalizable extends Serializable;
Metode de implementat pentru citire si scriere:
public void writeExternal(ObjectOutput out) throws IOException;
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException; // in si out sunt
fluxuri de citire si scriere la nivel de obiect
 Controlul versionării
• Un obiect serializat într-o anumită versiune de clasă trebuie deserializat în
aceeași versiune
• Controlul versiunii se face printr-un câmp static:
public static final long serialVersionUID = valoare;
• Dacă nu este declarat explicit, acest câmp este adăugat automat de JVM
• La momentul deserializării se compară valorile acestui câmp și este aruncată o
excepție de tipul InvalidClassException dacă acestea sunt diferite

Exemplu. E_nio