bytes.cat

---

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:

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();
       }
   }
}

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:

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(); }
 }
}

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

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(); }
    }
}

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

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(); }
 
    }
}

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»:

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();
    }
}

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

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();
   }
}

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 é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

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;
   }
}

StreamWriteMain.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(); }
   }
}

Exemple de com llegir un arxiu amb un objecte serialitzat:

StreamReadMain.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(); }
   }
}

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

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

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(); }
    }
}

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

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(); }
    }
}

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

Objecte serialitzable d'exemple.

Objecte.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;
    }
}

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(); }
    }
}

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

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(); }
    }
}

java-lecturaescriptura.zip