Module Java.10 – Fichiers & données

Objectif

Maîtriser la manipulation de fichiers, Streams, et JSON en Java pour persister et charger des données dans vos applications.

Théorie

Files (Java 7+)

API moderne pour manipuler les fichiers.

Lire un fichier

import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.Path;

// Lire tout le contenu
Path chemin = Paths.get("fichier.txt");
String contenu = Files.readString(chemin);  // Java 11+

// Lire toutes les lignes
List<String> lignes = Files.readAllLines(chemin);

// Lire en bytes
byte[] bytes = Files.readAllBytes(chemin);

Écrire dans un fichier

// Écrire (remplace le contenu)
Files.writeString(chemin, "Nouveau contenu");  // Java 11+

// Écrire des lignes
List<String> lignes = Arrays.asList("Ligne 1", "Ligne 2");
Files.write(chemin, lignes);

// Écrire en bytes
byte[] donnees = "Contenu".getBytes();
Files.write(chemin, donnees);

Vérifications

Path chemin = Paths.get("fichier.txt");

Files.exists(chemin);           // true si existe
Files.isRegularFile(chemin);    // true si fichier
Files.isDirectory(chemin);      // true si dossier
Files.isReadable(chemin);       // true si lisible
Files.isWritable(chemin);       // true si modifiable
Files.size(chemin);             // Taille en bytes

Streams (I/O classique)

Pour plus de contrôle sur la lecture/écriture.

Lecture

import java.io.*;

// FileReader (caractères)
try (FileReader reader = new FileReader("fichier.txt")) {
    int caractere;
    while ((caractere = reader.read()) != -1) {
        System.out.print((char) caractere);
    }
} catch (IOException e) {
    e.printStackTrace();
}

// BufferedReader (lignes)
try (BufferedReader reader = new BufferedReader(
        new FileReader("fichier.txt"))) {
    String ligne;
    while ((ligne = reader.readLine()) != null) {
        System.out.println(ligne);
    }
} catch (IOException e) {
    e.printStackTrace();
}

Écriture

// FileWriter
try (FileWriter writer = new FileWriter("fichier.txt")) {
    writer.write("Ligne 1\n");
    writer.write("Ligne 2\n");
} catch (IOException e) {
    e.printStackTrace();
}

// BufferedWriter (plus efficace)
try (BufferedWriter writer = new BufferedWriter(
        new FileWriter("fichier.txt"))) {
    writer.write("Ligne 1");
    writer.newLine();
    writer.write("Ligne 2");
} catch (IOException e) {
    e.printStackTrace();
}

JSON

Java n'a pas de support JSON natif, utilisez une bibliothèque.

Gson (Google)

Ajout de dépendance (Maven) :

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
</dependency>

Utilisation :

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

Gson gson = new Gson();

// Objet vers JSON
Personne personne = new Personne("Jean", 30);
String json = gson.toJson(personne);
// {"nom":"Jean","age":30}

// JSON vers objet
Personne p = gson.fromJson(json, Personne.class);

// Formatage lisible
Gson gsonPretty = new GsonBuilder()
    .setPrettyPrinting()
    .create();
String jsonPretty = gsonPretty.toJson(personne);

Jackson

Alternative populaire à Gson.

import com.fasterxml.jackson.databind.ObjectMapper;

ObjectMapper mapper = new ObjectMapper();

// Objet vers JSON
String json = mapper.writeValueAsString(personne);

// JSON vers objet
Personne p = mapper.readValue(json, Personne.class);

Sérialisation Java native

Java peut sérialiser des objets directement.

Serializable

import java.io.*;

class Personne implements Serializable {
    private static final long serialVersionUID = 1L;
    private String nom;
    private int age;
    
    // Constructeurs, getters, setters
}

// Sérialiser
try (ObjectOutputStream out = new ObjectOutputStream(
        new FileOutputStream("personne.ser"))) {
    out.writeObject(personne);
}

// Désérialiser
try (ObjectInputStream in = new ObjectInputStream(
        new FileInputStream("personne.ser"))) {
    Personne p = (Personne) in.readObject();
}

Limitations : Format binaire Java, pas portable.

Exercice

1. Files API

   • Lisez et écrivez des fichiers
   • Testez toutes les méthodes
   • Gèrez les erreurs

2. Streams

   • Utilisez FileReader/FileWriter
   • Utilisez BufferedReader/BufferedWriter
   • Comparez les performances

3. JSON

   • Installez Gson ou Jackson
   • Sérialisez/désérialisez des objets
   • Testez avec des structures complexes

4. Sérialisation

   • Testez Serializable
   • Comprenez les limitations
   • Comparez avec JSON

5. Cas pratique

   • Créez un système de sauvegarde/chargement
   • Utilisez JSON pour persistance
   • Gèrez les erreurs complètement

Quiz

1. Quelle API moderne pour fichiers (Java 7+) ?

   • FileReader
   • Files (java.nio.file)
   • InputStream

2. Que fait try-with-resources avec fichiers ?

   • Optimise la lecture
   • Ferme automatiquement les ressources
   • Gère les exceptions

3. Quelle bibliothèque pour JSON ?

   • java.json
   • Gson ou Jackson
   • json.jar

4. Que signifie Serializable ?

   • Peut être converti en String
   • Peut être sérialisé en binaire
   • Peut être lu

5. Quelle méthode lit toutes les lignes ?

   • Files.read()
   • Files.readAllLines()
   • Files.readLine()

Mini défi

Mission : Créer un système de sauvegarde/chargement

Créez un système qui sauvegarde et charge des données :

Fonctionnalités :

1. Sauvegarde en JSON (utilisez Gson)
2. Chargement depuis JSON
3. Gestion d'erreurs complète
4. Validation des données
5. Interface simple

Critères :

• ✅ Utilisation de Files API
• ✅ JSON avec Gson/Jackson
• ✅ Gestion d'erreurs appropriée
• ✅ Code robuste

Objectif : Maîtriser les fichiers et JSON pour persister des données.

---

Validation : Vous pouvez passer au module suivant quand vous maîtrisez Files, Streams et JSON.