Input/Output Streams

A computer communicates with the exterior world through one or more communication interfaces, also called input-output (IO) ports. E.g.: serial port, parallel port, video port, audio port, etc. By using these interfaces, the computer is able to transmit and receive information to and from the outside world through different peripheral devices (monitor, printer, keyboard, mouse, modem, Ethernet card, etc.).

Input/Output Streams

Considering the large number of peripheral types, the constant development of new ones and also the fact that existing peripherals are being constantly upgraded, direct communication between them and the software programs would be difficult to achieve if it were to only use the processor instructions (in/out). Furthermore, the complexity of the communication with the peripheral devices gets even higher with different types of communication: sequential/ random, binary/ character/ line by line, etc. In order to help with these problems, device drivers were developed, which are software modules used to control the peripherals and provide a simpler communication interface, however, they don't completely solve the compatibility issues of the IO operations. As a result, the operating system also introduces a layer of abstraction, offering a more uniform way of transferring data to and from the peripheral devices. However, programming languages, like Java, are created so that can be used in several operating systems and so additional standard functions are required, defined in the programming language libraries, to communicate with devices, independently of the operating system.

In order to treat communication uniformly, Java uses the concept of stream. The notion has been invented by Dennis Ritchie, who implemented the first IO system based on streams, in the Unix operating system, in year 1984. A stream implies the creation of a communication channel, generally valid, between two entities, either software or hardware, with the condition that one entity is a source, and the other is a destination. So, the source will transmit (write) information in the stream, and the destination will receive (read) from the stream. This way, the stream allows treating any communication channel between any entities in the system in the same way. Defining a stream is done by defining its two ends (source and destination). Because there are two communication directions, we can separate streams into two categories: input streams and output streams. Input streams are streams that connect to devices that provides data (like keyboards) and output streams connect to devices that receive data (like the monitor). Both source and destination can be either a peripheral device or software component.

Console Streams

Limbajul Java pune la dispoziția utilizatorului trei fluxuri standard pentru comunicare cu consola:

• fluxul standard de intrare (Standard Input) – de tip InputStream, folosit pentru citirea datelor;
• fluxul standard de ieșire (Standard Output) – de tip PrintStream, folosit pentru afișarea datelor;
• fluxul standard de eroare (Standard Error) – de tip PrintStream, folosit pentru afișarea erorilor.

În Java, toate fluxurile standard sunt accesate prin clasa java.lang.System. Astfel, pentru Standard Input există fluxul System.in, pentru Standard Output, System.out iar pentru Standard Error, System.err. Cei trei membri in, out, err ai clasei System sunt statici.

Clasele care descriu operațiile de intrare-ieșire se află în pachetul java.io. Acesta conține două categorii de fluxuri: fluxuri la nivel de octet și fluxuri la nivel de caracter. Fluxurile la nivel de octet au fost introduse începând cu versiunea JDK 1.0.2, iar fluxuruile la nivel de caracter au fost introduse începând cu versiunea JDK 1.1. Acestea din urmă nu înlocuiesc, ci completează funcționarea fluxurilor, cu posibilitatea de introducere și extragere a caracterelor (care în Java au 2 octeți).

Fluxuri de intrare-ieșire la nivel de octet

Fluxurile la nivel de octet (ca și fluxurile la nivel de caracter) se împart în fluxuri de intrare și fluxuri de ieșire.

Fluxuri de intrare la nivel de octet

Clasele pentru fluxurile la nivel de octet au ca rădăcină clasa InputStream, o clasa abstractă care oferă funcțiile de citire general valabile. Definiția clasei InputStream este:

public abstract class InputStream{
    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;
    public int available() throws IOException;
    public void close() throws IOException;
    public synchronized void mark(int readlimit);
    public synchronized void reset() throws IOException;
    public boolean markSupported();
}

Funcția read(), fără nici un parametru, citește octetul curent din flux și îl returnează sub forma unui întreg cu valori între 0 şi 255. Dacă s-a ajuns la capătul fluxului, se returnează valoarea –1.

Funcțiile read(), având ca parametru un tablou de octeți, citesc de la poziția curentă din flux un număr de octeți egal cu len sau cu lungimea tabloului b și îl scriu în vectorul b, la poziția off, dacă aceasta este specificată. Ele returnează numărul de octeţi citiți în buffer-ul b sau –1 dacă s-a ajuns la capătul fluxului.

Funcţia skip() este utilizată pentru a muta poziția cursorului de citire peste un anumit număr de octeți specificat prin parametrul n.

Funcțiile mark() și reset() se folosesc împreună, oferind posibilitatea reluării citirii din flux. Prin funcția mark() se memorează poziția curentă în flux, specificând prin argumentul readlimit maximul de octeți (se crează un buffer de dimensiune readlimit) care se pot citi până la apelul funcției reset(). Prin funcția reset() se repoziționează cursorul de citire din flux la poziția la care s-a făcut marcarea prin funcția mark(). Aceste două funcții sunt valabile doar în cazul în care fluxul suportă marcarea. Verificarea acestui lucru se face prin apelul funcției markSupported().

Funcţia available() returnează numărul de octeți disponibili pentru citire din flux.

Funcția close() este funcția care închide un flux. Odată terminat lucrul cu un flux, acesta trebuie închis, eliberând astfel resursele de sistem ocupate de acel flux. În mod normal JVM închide aceste fluxuri în momentul în care programul se termină.

Pentru a utiliza clasa InputStream în aplicații, a fost nevoie de construirea unor clase derivate din aceasta, clase care să fie conectate cu surse de date reale, existente în sistem. Din categoria claselor pentru fluxuri de intrare la nivel de octet conectate la diferite tipuri de resurse fac parte:

• ByteArrayInputStream permite conectarea unui flux la un tablou de octeți;
• FileInputStream oferă posibilitatea conectării cu un fișier pentru a citi datele înregistrate în acesta;
• SequenceInputStream permite combinarea mai multor fluxuri având ca rezultat obținerea unui singur flux;
• AudioInputStream permite conectarea cu un stream audio.

O altă categorie importantă de clase derivate din InputStream, de data aceasta însă nu direct, sunt clasele de tip filtru derivate din clasa FilterInputStream care este la rândul ei derivată din clasa InputStream. Aceste tipuri de clase nu oferă nici o alta sursă pentru fluxuri față de clasele amintite anterior. Ele lucrează ca o înfășurătoare a claselor care se conectează direct la sursă, oferind acestora din urmă funcții (proprietăți) suplimentare de citire din flux (exemplu: citire pe linie, citire numere, etc). Ca exemple de astfel de clase amintim:

• DataInputStream este una din cele mai utilizate clase dintre cele de tip filtru. Conține mai multe funcții care permit citirea unor tipuri fundamentale de date (int, float, etc) într-un mod independent de sistem și de mașină (procesor);
• PushbackInputStream oferă posibilități de revenire, permițând citirea din nou a datelor deja citite.

În continuare este prezentat un exemplu de utilizare a clasei ByteArrayInputStream:

byte _buffer[] = new byte[10];
for(byte i = 0; i < _buffer.length; i++){
    _buffer[i] = i;
}

ByteArrayInputStream _bufferStream = new ByteArrayInputStream(_buffer);
int _byteRead;
while((_byteRead = _bufferStream.read()) != -1){
    System.out.print(” ” + _byteRead);
}
System.out.println();

Prin intermediul clasei ByteArrayInputStream se pot citi datele din tablou utilizând operațiile de citire din flux, fără a mai fi nevoie de a contoriza poziția de citire din tablou. Conectarea se face simplu prin transmiterea tabloului respectiv ca și parametru în constructorul fluxului. Exemplul construiește un tablou de 10 octeți, inițializându-l cu valori de la 0 la 9, după care se citesc aceste valori din tablou prin intermediul fluxului creat. Se observă că citirea din flux se face până în momentul în care funcția read() returnează –1, semnalizând că s-a ajuns la sfârșitul fluxului, deci la sfârşitul tabloului.

Fluxuri de ieșire orientate pe octet

Pentru scrierea datelor folosind conceptul de flux orientat pe octet, se folosește o ierarhie de clase derivată din clasa OutputStream. Ca și clasa InputStream, clasa OutputStream este o clasa abstractă, oferind o interfață de declarare a unor metode de scriere general valabile. Clasa are următoarea definiție:

public abstract class OutputStream{
    public abstract void write(int i) throws IOException;
    public void write (byte b[]) throws IOException;
    public void write (byte b[], int off, int len) throws IOException;
    public long flush() throws IOException;
    public void close() throws IOException;
}

Funcţia write() scrie în flux octetul cel mai puțin semnficativ al argumentului, care este de tip int. Celelalte funcții permit scrierea în flux a unui tablou de octeți sau a unei secțiuni din tabloul de octeți b începând de la poziția off și având lungimea len.

Funcția flush() forțează scriea datelor în stream și este utilă în cazul în care se folosește un buffer de scriere (golește buffer-ul).

Funcția close() închide fluxul deschis prin operația de creare a fluxului, eliberând astfel orice resursă de sistem ocupată de fluxul respectiv.

Ca și în cazul clasei InputStream, clasele derivate din OutputStream pot fi separate în două categorii: fluxuri propriu-zise (ByteArrayOutputStream, FileOutputStream, etc) care se conectează la o destinație, și fluxuri de tip filtru (derivate din FilterOutputStream). Ultimele tipuri de fluxuri se conectează la primele, îmbogățind funcționarea acestora.

Fluxurile standard de ieșire (System.out) și de eroare (System.err) sunt membri statici ai clasei System de tipul PrintStream, care extinde clasa FilterOutputStream. Acestea sunt conectate cu display-ul și se folosesc prin convenție în două situații distincte: primul pentru afișarea mesajelor către utilizatorul programului, şi al doilea pentru afișarea mesajelor de eroare (de cele mai multe ori în scop de depanare).

În continuare este prezentat un exemplu de utilizare a clasei ByteArrayOutputStream, prin care se afișează toate valorile pe 8 biţi:

ByteArrayOutputStream _buffer = new ByteArrayOutputStream(256);
try{
    for(int i=0;i<256;i++) {
        _buffer.write(i);
    }
    _buffer.writeTo(System.out);
    byte[] _tablou = _buffer.toByteArray();
}catch(IOException _e){
    System.out.println("Eroare "+ _e.getMessage());
}

Clasa ByteArrayOutputStream este clasa corespondentă clasei ByteArrayInputStream și permite conectarea unui flux la un buffer (un tablou de octeți). Buffer-ul se crează în momentul în care un obiect de tipul ByteArrayOutputStream se instanțiază folosind unul dintre cei doi constructori. Această clasă oferă o metodă de stocare a datelor în memorie înainte de a le trimite mai departe. Pentru transmiterea datelor se folosește metoda writeTo(). Această funcție scrie conținutul buffer-ului în fluxul out transmis ca parametru. Spre deosebire de clasa ByteArrayInputStream unde tabloul (buffer-ul) era transmis prin constructorul clasei, în cazul clasei ByteArrayOutputStream, pentru a avea o referintă la acest buffer, este nevoie să se apeleze funcția toByteArray(). Această funcție creează un tablou de dimensiune egală cu numărul de octeți înscriși în flux și care conține acești octeți.

Fluxuri de intrare-ieșire la nivel de caracter

Clasele pentru fluxurile la nivel de caracter au la bază clasa Reader pentru citirea datelor și clasa Writer pentru scrierea datelor. Majoritatea acestor clase se suprapun peste clasele pentru fluxurile la nivel de octet, oferind în principal aceleași funcționalități. Deosebirea între clasele de tip InputStream/OutputStream și cele de tip Reader/Writer este aceea că primele clase lucrează cu fluxuri de octeți (8 biți), în timp ce ultimele lucrează cu fluxuri de caractere reprezentate pe 16 biți în format Unicode (standard internațional de codare a caracterelor care este capabil să reprezinte caracterele tuturor limbilor scrie).

Cu toate că noile clase Reader/Writer dublează clasele InputStream/OutputStream, acestea din urmă nu au fost abandonate, datorită în principal cerinței de compatibilitate cu aplicațiile dezvoltate într-o versiune mai veche de Java. Totuși, există unele metode din vechile clase care se recomandă a nu a mai fi folosite, fiind caracterizare ca depășite (deprecated). Funcțiile oferite de clasele InputStream/OutputStream se regăsesc în clasele Reader/Writer cu mici deosebiri, acest lucru reflectându-se și în denumirile asemănătoare ale celor două tipuri de clase de tip flux, prefixele fiind aceleași. În cazul claselor de citire a datelor se pot observa următoarele corespondențe:

• InputStream - Reader
• ByteArrayInputStream – CharArrayReader
• StringBufferInputStream – StringReader
• FileInputStream – FileReader
• Există unele clase, SequenceInputStream, și DataInputStream care nu au o versiune de tip Reader.

În cazul claselor pentru scriere, se pot observa următoarele corespondențe:

• OutputStream - Writer
• ByteArrayOutputStream – CharArrayWriter
• FileOutputStream – FileWriter