====== Lectura i escriptura d'arxius a Java ======

{{tag> #FpInfor #Dam #DamMp06 #DamMp06Uf1 #DamMp06Uf01}}

----

==== Tipus d'arxius ====

Hi ha dos tipus d’arxius:

- De text: guarden dades en format text (caràcters llegibles)

- Binaris: guarden dades en format binari (0s i 1s)

Per llegir arxius de text fem servir dues classes:

- **File**: representa una ruta al sistema de fitxers, i permet

  * Manipular la jerarquia d’arxius (crear arxius i carpetes, borrar, renombrar …)

  * Manipular els atributs dels arxius (permissos, ocultació …)

- **Scanner**: permet llegir els continguts d’un arxiu, s’ha de fer amb un bucle ‘while’ i la funció ‘.nextLine()’

Exemple de lectura d'arxius de text:

<code java>
package FileReadWrite;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class Main {
   public static void main(String args[]) {
       int lineNumber = 1;
       File text = new File("./Main.java");
       Scanner scnr;
       try {
           scnr = new Scanner(text);
           while(scnr.hasNextLine()){
               String line = scnr.nextLine();
               System.out.println("line " + lineNumber + " :" + line);
               lineNumber++;
           }
       } catch (FileNotFoundException e) {
           e.printStackTrace();
       }
   }
}
</code>

Per escriure arxius de text fem servir dues classes:

- **FileWriter**: permet accedir a arxius en mode escriptura, el mètode ‘write()’ permet escriure cadenes de caràcters.
  * El seu constructor accepta un segon paràmetre per afegir dades a l’arxiu

- **PrintWriter**: permet escriure caràcters al fitxer (igual que en pantalla)


Exemple d'escriptura d'arxius de text:

<code java>
import java.io.File;  // Import the File class
import java.io.IOException;  // Import the IOException class to handle errors
import java.io.FileWriter;   // Import the FileWriter class
import java.io.IOException;  // Import the IOException class to handle errors

public class MainWrite {
 public static void main(String[] args) {
   try {
     File myObj = new File("writefile.txt");
     if (myObj.createNewFile()) {
       System.out.println("File created: " + myObj.getName());
     } else {
       System.out.println("File already exists.");
     }
   } catch (IOException e) { e.printStackTrace(); }
   try {
       FileWriter myWriter = new FileWriter("writefile.txt");
       myWriter.write("Files in Java might be tricky, but it is fun enough!");
       myWriter.close();
       System.out.println("Successfully wrote to the file.");
     } catch (IOException e) { e.printStackTrace(); }
 }
}
</code>


==== Escriptura i lectura d'arxius amb dades de List<String> ====

Per escriure arxius per guardar-hi les dades d'una llista de textos, es pot fer amb:

<code java>
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;

// Aquest exemple escriu els continguts
// d'una List<String> en un arxiu de text

public class EscripturaArxiuList {
    public static void main(String args[]) {
        String basePath = System.getProperty("user.dir") + "/";
        String filePath = basePath + "ArxiuEscriu.txt";

        System.out.println("");

        try {
            List<String> linies = new ArrayList<String>();
            linies.add("Del xoc i la confusió apareixen les pors,");
            linies.add("perills i destruccions inapreciables per la");
            linies.add("majoria de la gent, per sectors específics");
            linies.add("de la societat i la majoria de governants.");
            linies.add("La natura, a través d'huracans, terratrèmols,");
            linies.add("fam i pandèmies genera xoc i confusió.");

            Path out = Paths.get(filePath);
            Files.write(out, linies, Charset.defaultCharset());

            System.out.println("Llest");

        } catch (IOException e) { e.printStackTrace(); }
    }
}
</code>

Per llegir arxius guardats amb el mètode anterior cap a una List<String>:

<code java>
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;

// Aquest exemple llegeix un arxiu de text en una List<String>

public class LecturaArxiuList {
    public static void main(String args[]) {
        String basePath = System.getProperty("user.dir") + "/";
        String filePath = basePath + "Arxiu.txt";

        System.out.println("");

        try {
            List<String> linies = Files.readAllLines(Paths.get(filePath), StandardCharsets.UTF_8);
            for (int cnt = 0; cnt < linies.size(); cnt = cnt + 1) {
                System.out.println(linies.get(cnt));
            }
        } catch (IOException e) { e.printStackTrace(); }

    }
}
</code>


==== DataOutputStream i DataInputStream ====

Per guardar dades primitives de manera ordenada en arxius, hi ha les classes "**DataOutputStream**" i "**DataInputStream**". Les dades, s'han de llegir en el mateix ordre que s'han guardat.

Exemple de guardar dades primitives amb "DataOutputStream":

<code java>
File file = new File("outin.bin");
      
FileOutputStream fileOutputStream = null;
DataOutputStream dataOutputStream = null;
try {
    fileOutputStream=new FileOutputStream(file);
    dataOutputStream=new DataOutputStream(fileOutputStream);
    dataOutputStream.writeInt(50);
    dataOutputStream.writeDouble(400.25);
    dataOutputStream.writeUTF(“Hola”);
    dataOutputStream.flush();
} catch (IOException e) {
    e.printStackTrace();
} finally {
    try {
        if(fileOutputStream!=null){ fileOutputStream.close(); }
        if(dataOutputStream!=null){ dataOutputStream.close(); }
    } catch (Exception e) {
        e.printStackTrace();
    }
}
</code>

Exemple de llegir dades primitives amb "DataInputStream":
(Es llegeixen en l'ordre que s'han escrit)

<code java>
FileInputStream fileInputStream = null;
DataInputStream dataInputStream = null;
try {
   fileInputStream = new FileInputStream(file);
   dataInputStream = new DataInputStream(fileInputStream);
   System.out.println(dataInputStream.readInt());
   System.out.println(dataInputStream.readDouble());
   System.out.println(dataInputStream.readUTF());
} catch (IOException e) {
   e.printStackTrace();
}finally {
   try {
     if(fileInputStream!=null){ fileInputStream.close(); }
     if(dataInputStream!=null){ dataInputStream.close(); }
   } catch (Exception e) {
      e.printStackTrace();
   }
}
</code>

Cal tenir en compte que els objectes no són dades primitives i per tant no es poden guardar i llegir amb els mètodes anteriors.


==== Serialitzar ====


Serialitzar és transformar un objecte en una cadena de bytes que es poden llegir per reconstruir l’objecte original.

Serialitzar permet guardar objectes JAVA en arxius o transmetre’ls a través de la xarxa.

Per fer que una classe sigui serialitzable en JAVA ha de implementar: ‘**implements java.io.Serializable**’

Exemple de guardar un objecte "Serialitzable" en un arxiu binari:

StreamEmployee.java
<code java>
import java.io.Serializable;

public class StreamEmployee implements Serializable {

   private static final long serialVersionUID = -299482035708790407L;
   private String name;
   private String gender;
   private int age;
   private String role;

   public StreamEmployee(String n) { this.name = n; }
   public String getGender() { return gender; }
   public void setGender(String gender) { this.gender = gender; }
   public int getAge() { return age; }
   public void setAge(int age) { this.age = age; }
   public String getRole() { return role; }
   public void setRole(String role) { this.role = role; }
   @Override
   public String toString() {
       return "Employee:: Name=" + this.name + " Age=" + this.age + " Gender=" + this.gender + " Role=" + this.role;
   }
}

</code>

StreamWriteMain.java
<code java>
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.IOException;

public class StreamWriteMain {
   public static void main(String[] args) {

       StreamEmployee emp = new StreamEmployee("Pankaj");

       emp.setAge(35);
       emp.setGender("Male");
       emp.setRole("CEO");
       System.out.println(emp);
      
       try {
           FileOutputStream fos = new FileOutputStream("EmployeeObject.ser");
           ObjectOutputStream oos = new ObjectOutputStream(fos);
           oos.writeObject(emp);
           System.out.println("Done");
           oos.close();
           fos.close();
       } catch (IOException e) { e.printStackTrace(); }
   }
}
</code>

Exemple de com llegir un arxiu amb un objecte serialitzat:

StreamReadMain.java
<code java>
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.IOException;

public class StreamReadMain {
   public static void main(String[] args) {

       FileInputStream is;
       try {
           is = new FileInputStream("EmployeeObject.ser");
           ObjectInputStream ois = new ObjectInputStream(is);
           StreamEmployee emp = (StreamEmployee) ois.readObject();

           ois.close();
           is.close();
           System.out.println(emp.toString());
       } catch (ClassNotFoundException e) {
           e.printStackTrace();
       } catch (IOException e) { e.printStackTrace(); }
   }
}
</code>

**Nota**: Cal tenir en compte, que els objectes serialitzats només es poden llegir en la mateixa versió de Java.

==== Escriptura i lectura d'arxius amb dades de ArrayList<> d'Objectes ====

Per escriure arxius per guardar-hi les dades d'un ArrayList, es pot fer amb:


<code java>
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

// En aquest exemples es
// guarda una llista d'objectes
// serializables en un arxiu binari

public class EscripturaLlistes {
    public static void main(String args[]) {
        String basePath = System.getProperty("user.dir") + "/";
        String filePath = basePath + "ArxiuEscriuLlistes.dat";

        System.out.println("");

        Objecte obj0 = new Objecte("Escriptori", "Estudiar");
        Objecte obj1 = new Objecte("Telèfon", "Perdre el temps");

        ArrayList<Objecte> llista = new ArrayList<>();
        llista.add(obj0);
        llista.add(obj1);

        try {
            FileOutputStream fos = new FileOutputStream(filePath);
            ObjectOutputStream oos = new ObjectOutputStream(fos);

            oos.writeObject(llista.toArray(new Objecte[0]));
            oos.close();
            fos.close();

            System.out.println("Llest");

        } catch (IOException e) { e.printStackTrace(); }
    }
}
</code>

Per llegir arxius guardats amb el mètode anterior cap a una ArrayList:

<code java>
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;
import java.util.Arrays;

// En aquest exemples es
// llegeix una llista d'objectes
// serializables des de un arxiu binari

// És pràctic guardar-ho en una llista
// perquè així no cal saber quants objectes
// cal llegir

public class LecturaLlistes {
    public static void main(String args[]) {
        String basePath = System.getProperty("user.dir") + "/";
        String filePath = basePath + "ArxiuEscriuLlistes.dat";

        System.out.println("");

        try {
            FileInputStream fis = new FileInputStream(filePath);
            ObjectInputStream ois = new ObjectInputStream(fis);

            ArrayList<Objecte> llista = new ArrayList<>(Arrays.asList((Objecte[]) ois.readObject()));

            for (int cnt = 0; cnt < llista.size(); cnt = cnt + 1) {
                System.out.println(llista.get(cnt));
            }

            ois.close();
            fis.close();

        } catch (ClassNotFoundException e) { e.printStackTrace();
        } catch (IOException e) { e.printStackTrace(); }
    }
}
</code>

==== Lectura i Escriptura d'Objectes de manera ordenada ====

Igualment, com amb les dades primitives, es poden guardar objectes de manera ordenada:

Objecte serialitzable d'exemple. 

Objecte.java
<code java>
import java.io.Serializable;

public class Objecte implements Serializable {
    String nom;
    String utilitat;

    Objecte (String nom, String utilitat) {
        this.nom = nom;
        this.utilitat = utilitat;
    }

    @Override
    public String toString () {
        return "Nom: " + this.nom + ", Utilitat: " + this.utilitat;
    }
}

</code>

<code java>
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

// En aquest exemple s'escriu un arxiu
// binari amb objectes JAVA serializables
// S'hauràn de llegir en el mateix
// ordre que s'han escrit

public class EscripturaObjectes {
    public static void main(String args[]) {
        String basePath = System.getProperty("user.dir") + "/";
        String filePath = basePath + "ArxiuEscriuObjectes.dat";

        System.out.println("");

        try {
            FileOutputStream fos = new FileOutputStream(filePath);
            ObjectOutputStream oos = new ObjectOutputStream(fos);

            Objecte obj0 = new Objecte("Escriptori", "Estudiar");
            Objecte obj1 = new Objecte("Telèfon", "Perdre el temps");

            oos.writeObject(obj0);
            oos.writeObject(obj1);

            oos.close();
            fos.close();

            System.out.println("Llest");
        } catch (IOException e) { e.printStackTrace(); }
    }
}
</code>

Per llegir els objectes guardats amb el mètode anterior:

<code java>
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class LecturaObjectes {
    public static void main(String args[]) {
        String basePath = System.getProperty("user.dir") + "/";
        String filePath = basePath + "ArxiuEscriuObjectes.dat";

        System.out.println("");

        try {
            FileInputStream fis = new FileInputStream(filePath);
            ObjectInputStream ois = new ObjectInputStream(fis);

            Objecte obj0 = (Objecte) ois.readObject();
            Objecte obj1 = (Objecte) ois.readObject();

            System.out.println(obj0);
            System.out.println(obj1);

            ois.close();
            fis.close();

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) { e.printStackTrace(); }
    }
}
</code>

==== Exemples ====

{{ ::java-lecturaescriptura.zip |}}