Fluxurile Java pun la dispozitie modalitatea prin care doua sau mai multe procese pot comunica fara a avea informatii unul despre celalalt. Mai mult, prin fluxuri este posibila comunicarea între doua sau mai multe fire de executie ale aceleiasi aplicatii. Fluxurile sunt secvente de octeti (8 biti).

  • fluxurile sunt unidirectionale, de la producator la consumator

  • fiecare flux are un singur proces producator si un singur proces consumator

  • între doua procese pot exista oricâte fluxuri, orice proces putând fi atât producator si consumator în acelasi timp, dar pe fluxuri diferite

  • consumatorul si producatorul nu comunica direct printr-o interfata de flux ci prin intermediul codului Java de tratare a fluxurilor

Importanta : ajuta la citirea scrierea informatiilor in dispozitive de intrare/iesire, fisiere, baze de date, etc.

Toate interfetele pentru fluxuri implementeaza un set de metode de baza, comune tuturor categoriilor de fluxuri. Metodele standard pentru lucrul cu fluxuri se gasesca în pachetul java.io.

Fluxuri de intrare

BufferedInputStream

citeste datele dintr-un buffer

ByteArrayInputStream

citeste octetii de date într-o matrice de octeti

DataInputStream

citeste dintr-un flux de intrare obiecte, nu siruri de octeti

FileInputStream

citeste date dintr-un fisier

FilterInputStream

InputStream

LineNumberInputStream

PipedInputStream

PushBackInputStream

SequenceInputStream

StringBufferInputStream

Metode care functioneaza cu toate fluxurile de intrare :

  • read() - citeste date dintr-un flux de intrare

  • skip() - ignora unele date din fluxul de intrare

  • markAvailable() - testeaza daca metoda mark() este disponibila pentru fluxul de intrare respectiv

  • close() - închide un flux de intrare

Read

        int read();
        int read(byte[] buffer)
        int read(byte[] buffer, int offset, int length)

Skip

    long skip(long numar_octeti)
    public long skipN(int n)
    {
        int recordSize = 1024 ;
        long retNum = 0 ;
        try
        {
            //sare peste n inregistrari
            retNum = MyStream.skip(n * recordSize);
            //calc nr. de inregistrari peste care a sarit
            if retNum > 0
            {
                retNum /= recordSize ;
            }

            return (retNum);
        }catch (IOException e)
        {
            System.out.println.(e.getMessage());
        }

    } 

Close

   public long closeStream() 
    {
       try
       {
        MyStream.close();
       }catch (IOException e)
       {
        System.out.println("Eroare la inchiderea fluxului");
       }
    }

Metode a caror functionare nu este garantata pentru toate fluxurile de intrare :

  • available() - determina cantitatea de date disponibile într-un flux de intrare

  • mark() - marcheaza în fluxul de intrare un punct la care se poate reveni ulterior

  • reset() - revine la un punct dpecificat în fluxul de intrare

Read

  • int read ();

  • int read (byte[] buffer)

  • int read (byte[] buffer, int offset, int length)

Skip

  • long skip (long numar_octeti)

Exemplu:

public long skipRecords(int num)
    {
        int recordSize = 512;
        long retCode = 0;

        try
        {
            //sare peste num inregistrari
            retCode = MyStream.skip(num * recordSize);
            //calc nr. de inregistrari peste care a sarit
            if retCode > 0
            {
                retCode /= recordSize;
            }
            catch(IOException e)
            {
                System.out.println("Eroare de intrare/iesire!");
            }
            return (retCode);
        }
    }

Close

închide un flux de intrare (Java închide automat fluxurile la terminarea aplicatiei)

  • void close();

Exemplu:

public long closeStream()
{
        try 
        {
            MyStream.close();
        }
         catch (IOException e) 
        {
            System.out.println("Eroare la inchiderea fluxului");
        }
}   

Available

determina daca o anumita cantitate de date poate fi citita fara blocarea fluxului de intrare.

  • int available()

Returneaza nr. de octeti ce pot fi cititi din fluxul de intrare fara blocare.

Exemplu:

 public boolean isRecordReady()
 {
        int recordSize = 512 ;
        boolean ret = false ;
        try
        {
            if (MyStream.available() >= recordSize)
                ret = true;
        }
        catch (IOException e) 
        { ... }
        return ret;
  }

Fluxuri de iesire

Clase pentru fluxuri de iesire :

  • FileOuputStream

  • BufferedOutputStream

  • ByteArrayOutputStream

  • DataOutputStream

  • FilterOutputStream

  • OutputStream

  • PipedOutputStream

  • PrintStream

Metode pentru fluxurile de iesire

  • write() - scrie date într-un flux de iesire

  • flush() - forteaza scrierea datelor într-un canal de redirectare

  • close() - închide un flux de iesire

Write

  • int write ();

  • int write (byte[] buffer)

  • int write (byte[] buffer, int offset, int length)

Flush

forteaza scrierea catre dispozitivul de iesire a datelor stocate în zona tampon pentru un flux de iesire.

  • void flush();

Close

închide un flux de iesire (Java închide automat fluxurile la terminarea aplicatiei)

  • void close();

RECOMANDARE: Operatiile read/write se recomanda a fi facute în fire de executie separate care sa nu blocheze programul.

import java.io.*
    public class TestFlux
{

    public static void main(String args[])
    {
        FileInputStream s,sursa; //s este flux de intrare
        FileOutputStream dest; //dest este flux de iesire
        int octet;
        try
        {
            sursa = new FileInputStream(args[0]);

            try
            {
                dest = new FileOutputStream(args[1]);
                octet = 0;
                //citesc fisierul caracter cu caracter
                while (octet != -1)
                {
                    try
                    {
                        octet = sursa.read();
                        dest.write(octet);
                        System.out.print((char)octet);
                    }
                    catch (IOException e) 
                    {
                        System.out.println("Eroare de intrare/iesire");
                        System.exit(2);
                    }
                } //while
            }//try
            catch (IOException e)
            {
                System.out.println("Fisierul " + args[1] + " nu a putut fi creat !");
                System.exit(2);
            }

        }//try

        catch (FileNotFoundException e)
        {
            System.out.println("Fisierul " + args[0] + " nu a fost gasit !");
            System.exit(1);
        }

    }//main
}//class


    

Back to Top