Taula de continguts

Lectura i escriptura d'arxius a Java

, , , ,

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

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

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

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: 

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

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

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

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.

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: 

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

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 

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

Exemples

java-lecturaescriptura.zip