Mostra la font per a DAM-M3-UF5. Lectura i escriptura. Fitxers

torna [[ M3 - Programació ]]

== Lectura i escriptura ==

Hi ha múltiples ocasions on cal introduir dades a un programa o mostra-les a la sortida, per exemple:

* Línia de comandes

* Formulari amb elements gràfics

* Fitxers

* Pipes o sockets

Java tracta la entrada i sortida d'informació establint uns corrents o fluxes ('''stream'''), a través dels quals trasllada blocs de dades ('''buffer''').

Aquests fluxes sempre són binaris evidentment, però Java ofereix dos possibles tractaments:

* '''Fluxe binari''' (bytes), classes InputStream, outputStream
* '''Fluxe de caràcters''' , classes Reader, Writer


=== Mètodes bàsics ===

A través de la entrada i sortida estàndard

* System.in, és un fluxe binari (InputStream), que recull les dades entrades per consola
* System.out, és un fluxe binari (OutputStream -> PrintStream) amb algunes funcionalitats de tractament, converteix caràcters a bytes segons codificació de la plataforma.


=== La classe Scanner ===

La classe Scanner és una funció d'utilitat simple per a la lectura de dades tipus primitius (int, String, etc...) o qualsevol Objecte que implementi ''Readable''.

Trenca la lectura segons el delimitador (Per defecte un espai en blanc, encara que es pot modificar)

<pre>
        Scanner sc = new Scanner( System.in );

        System.out.print( "Escriu un text: " );
        String dada = sc.next();
        System.out.println( "Has escrit: " + dada);
</pre>


A més implementa la interface Iterator de manera que permet gestionar la lectura amb les operacions de control dels iteradors

* hasNext()
* next()

<pre>
        do {
            System.out.print( "Escriu \"Fi\" per acabar: " );
            dada = sc.next();
           
        } while (!dada.equals("Fi"));
</pre>

També permet definir diferents tipus d'entrada com fitxers o cadenes de text, i té mètodes específics per a la lectura d'enters, decimals, etc...


<pre>
        String dada = "aaa bbb ccc ddd";
        Scanner sc = new Scanner(dada);
        do {
            dada = sc.next();
            System.out.println( "Conté: " + dada);           
        } while (sc.hasNext());

        dada = "1 2 3 4";
        Scanner sc = new Scanner(dada);
        do {
            System.out.println( "Conté: " + sc.nextInt());           
        } while (sc.hasNextInt());
</pre>



=== Readers / Writers ===

A part dels sistemes anteriors, Java proporciona una capa d'utilitats entre la entrada i l'usuari que permet fer un tractament semblant independentment del tipus d'entrada o sortida que es faci servir.

Les classes utilitzades per al tractament de fluxes de caràcters hereten de '''java.io.Reader''' i de '''Java.io.Writer'''


'''Exemple lectura de consola''', obliga a gestionar les excepcions

<pre>
public static void main(String[] args) throws IOException {
        //primer();

        InputStreamReader is = new InputStreamReader(System.in);        // Entrada, estandard

        BufferedReader in = new BufferedReader(is);            // buffer   

        String text = in.readLine(); //Lectura String
       
        int num = Integer.parseInt(in.readLine()); //Lectura Enter
        ...
}

</pre>

'''Exemple entrada de fitxers''', observar que també usa la classe ''BufferedReader'', una vegada inicialitzat aquest el tractament és independent del tipus d'entrada.

<pre>
        File fitxer = new File("nom");    // Adreçament relatiu   
        FileReader fr = null;        // Entrada
        BufferedReader br;            // buffer   
        String linea;

        try {
            fr = new FileReader (fitxer); // Inicialitza entrada del fitxer
            br = new BufferedReader(fr);     // Inicialitza buffer amb l’entrada
            while((linea=br.readLine())!=null)  {
                System.out.println(linea);
            }
        } catch (FileNotFoundException e) {
            System.out.println("Fitxer no existeix");
        } catch (IOException e) {
            System.out.println(e.getMessage());
        } finally {
            if (fr != null) fr.close();
        }
</pre>


'''Exemple escriptura a fitxer'''

<pre>
        boolean append = true;
        FileWriter fw = new FileWriter("nom", append);
        PrintWriter pw = new PrintWriter(fw, true);
         
        try {
            int i = 0;
            while (i < 10) {
                pw.println("linia " + i++);
            }
        } catch (Exception e) {
            System.out.println(e.getMessage());
        } finally {
            fw.close();
        }
</pre>


=== Fitxers ===

Els fitxers permeten emmagatzemar dades, aquestes dades poden ser de dos tipus:
* '''Text''', dades alfanumèriques
* '''Binari''', dades en binari

==== Modes d'accés. Accés aleatori ====

L'accés a les dades dels fitxers es pot fer de dues maneres
* '''Seqüencialment''', s'obre el fitxer i es llegeix les dades des de l'inici. Aquest tipus de fitxers no tenen cap estructura especial.

Java proporciona la classe '''File''' per a l'accés seqüencial. Les dades poden ser tant text com binàries. Aquesta classe representa directament els objectes del sistema de fitxers i les seves propietats.

* De forma '''aleatòria''', s'obre el fitxer i s'accedeix a una dada concreta. Per a permetre aquest tipus d'accés cal definir certes estructures especials on desar els apuntadors (índexs, ''file pointers'').

Java proporciona la classe '''RandomAccessFile''' per a l'accés aleatori, els fitxers són '''binaris''' i tenen un '''índex''' que permet accedir a posicions concretes. Aquesta classe és una abstracció més allunyada que ''File'' dels objectes del sistema de fitxers, doncs incorpora estructures pròpies que gestiona Java.


==== Classe File ====

La classe '''File''' permet treballar amb fitxers i directoris.


<pre>
        File f = new File("fitxer");
       
        if (f.exists()) System.out.println("el fitxer existeix");
        else {
            System.out.println("el fitxer NO existeix, el creem");
            f.createNewFile();
        }
       
        System.out.println("path: " + f.getPath());    // fitxer
        System.out.println("path absolut: " + f.getAbsolutePath()); // {path_to_file}/fitxer
        System.out.println("ultima modificació : " + new Date((long)f.lastModified()*1000));
        System.out.println("longitud : " + f.length());
       
        f.setExecutable(true);
       
        if (f.canExecute()) System.out.println("execució");
        if (f.canRead()) System.out.println("lectura");
        if (f.canWrite()) System.out.println("escriptura");
        if (f.isFile()) System.out.println("fitxer");
        if (f.isDirectory()) System.out.println("directori");
        if (f.isHidden()) System.out.println("ocult");
       
        File d = new File("directori");
        if (d.exists()) System.out.println("el directori existeix");
        else {
            System.out.println("el directori NO existeix, el creem");
            d.mkdir();
        }
        if (d.isDirectory()) System.out.println("directori");
       
        String[] fitxers = d.list();
        for (int i = 0; i < fitxers.length; i++) {
            System.out.println("fitxer " + fitxers[i]);   
        }
</pre>

==== Classe RandomAccessFile ====

{{ Pendent }}

=== Emmagatzematge d'objectes ===

En una primera aproximació a la persistència, es poden fer servir fitxers per emmagatzemar els objectes d'un sistema informàtic.

Existeixen dues possibilitats raonables:
* Serialització i emmagatzematge (dades en binari)
* Emmagatzematge estructurat, per exemple XML, dades tipus text

<strike>http://java.sun.com/products/jfc/tsc/articles/persistence3/

Cal descartar qualsevol altre solució, com per exemple mapejar els objectes en fitxers amb estructures de files i separant els valors dels atributs per ";" (p.e. format csv).</strike>

==== XML ====

Java proporciona dues classes que permeten transformar directament objectes a fitxers XML i després recuperar-los novament

* XMLEncoder
* XMLDecoder

Aquest mètode només permet treballar amb objectes JavaBeans, aquests compleixen certes restriccions

http://ca.wikipedia.org/wiki/JavaBeans
https://www.oracle.com/technetwork/java/persistence4-140124.html 

<pre>
public class Cercle {
    private Punt centre;
    private int radi;
   
    public Cercle() { }
   
    public Cercle(Punt centre, int radi) {
        this.centre = centre;
        this.radi = radi;
    }

    public Punt getCentre() {
        return centre;
    }
    public void setCentre(Punt centre) {
        this.centre = centre;
    }
    public int getRadi() {
        return radi;
    }
    public void setRadi(int radi) {
        this.radi = radi;
    }
}

public class Punt {
    private int x;
    private int y;

    public Punt() { }

    public Punt(int x, int y) {
        this.x = x;
        this.y = y;
    }
   
    public int getX() {
        return x;
    }
    public void setX(int x) {
        this.x = x;
    }
    public int getY() {
        return y;
    }
    public void setY(int y) {
        this.y = y;
    }
}

public class XMLexample {
    public static void main(String[] args) throws FileNotFoundException {
        Punt p = new Punt(2,4);
        Cercle c = new Cercle(p, 10);
       
        // Serialització
        XMLEncoder e;
        e = new XMLEncoder(new BufferedOutputStream(new FileOutputStream("cercle3.xml")));
        e.writeObject(c);
        e.close();
       
        // Recuperació
        XMLDecoder d = new XMLDecoder(new BufferedInputStream(new FileInputStream("cercle3.xml")));
        Cercle cxml = (Cercle) d.readObject();
        d.close();
       
        System.out.println("Cercle radi " + cxml.getRadi());
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<java version="1.6.0_24" class="java.beans.XMLDecoder">
 <object class="dam.m3.uf4.Cercle">
  <void property="centre">
   <object class="dam.m3.uf4.Punt">
    <void property="x">
     <int>2</int>
    </void>
    <void property="y">
     <int>4</int>
    </void>
   </object>
  </void>
  <void property="radi">
   <int>10</int>
  </void>
 </object>
</java>

</pre>

==== Serialització ====

El procés de serialització consisteix en convertir les dades i els objectes en dades binàries, mantenint-ne la estructura.

Es poden serialitzar '''dades primitives''' i '''objectes''' complexes.

Per a serialitzar objectes cal que aquests implementin la interface "Serializable" (No cal que siguin JavaBeans)

Cal tenir en compte que la informació es recupera en el mateix ordre que s'escriu.


<pre>

public class Punt implements Serializable {
...
}

public class Cercle implements Serializable {
...
}

public class Serializablexample {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Punt p = new Punt(2,4);
        Cercle c1 = new Cercle(p, 10);
        Cercle c2 = new Cercle(p, 12);
       
        // Serialització
        ObjectOutputStream fileOut = new ObjectOutputStream(new FileOutputStream("fitxer.bin"));
        fileOut.writeObject("hola que tal");
        fileOut.writeObject(c1);
        fileOut.writeObject(c2);
        fileOut.close();
       
        // Recuperació
        ObjectInputStream fileIn = new ObjectInputStream(new FileInputStream("fitxer.bin"));
        System.out.println((String) fileIn.readObject());
       
        try {
            while (true) {
                Cercle aux = (Cercle) fileIn.readObject();
                System.out.println("Cercle radi " + aux.getRadi());
            }
        } catch (EOFException e) {
            fileIn.close();
        } catch (Exception e) {
            if (fileIn != null) fileIn.close();
            System.out.println("Error");
        }
    }
}
</pre>