Badr Benmammar badr.benmammar@gmail.com Master Réseaux et Systèmes Distribués (RSD) Algorithmique des systèmes et applications réparties (pré requis) Badr Benmammar badr.benmammar@gmail.com

Plan - Pré requis Gestion des fichiers Classe File Quelques flots : FileReader : lire un fichier caractère par caractère FileWriter : écrire des caractères dans un fichier PrintWriter : println et print dans un fichier BufferedReader : rechercher un mot dans un fichier Sérialisation : enregistrer et restaurer des objets L’interface Serializable ObjectOuputStream : écrire des objets dans un fichier ObjectInputStream : lire des objets à partir d’un fichier

Gestion des fichiers

Gestion des fichiers : classe File import java.io.*; public class Fichier extends File { public Fichier (String nomFichier) { super (nomFichier); } public boolean lirePossible() { return (this.exists()&&this.isFile()&&this.canRead()); public boolean ecrirePossible() { return (this.exists()&&this.isFile()&&this.canWrite());

Gestion des fichiers : classe File Classe Fichier : Permet d'instancier un objet File par le nom (chemin relatif ou absolu) de ce fichier ou répertoire. Permet de savoir si le fichier est accessible en lecture ou écriture. Classe File du package io : Quelques méthodes : boolean exists si le fichier ou répertoire existe. boolean isFile si c'est un fichier. boolean canRead s'il est accessible en lecture. boolean canWrite s'il est accessible en écriture.

Flot de lecture Etant donné la quantité d’information d’un fichier, il est peu conseillé voire impossible de le charger d'un bloc dans une variable. Un flot (ou flux) en lecture permet d’y accéder au fer et à mesure : donnée par donnée, "un peu comme un tuyau". Le flot doit être ouvert puis on accède aux données selon la nature du flot : Caractère par caractère. Par blocs de caractère. Avec la gestion d'un tampon. Séquentiellement ou directement à tel position. ..... Ces différents modes expliquent le nombre important de classes de flot en Java. Enfin on le ferme.

Lire un fichier caractère par caractère et l’afficher à l’écran import java.io.*; public class LireFichier1 { public static void main(String[] args) { Fichier fichier= new Fichier("test"); try { FileReader flotLecture = new FileReader (fichier); long longueurFichier= fichier.length(); int dejaLu = 0; char car=0; while (dejaLu < longueurFichier) { car= (char)flotLecture.read(); dejaLu = dejaLu + 1; System.out.print(car); } // fin while flotLecture.close(); } catch (IOException e) {System.out.println(" erreur :" + e.toString());} } // fin main } // fin classe Le fichier test se trouve dans votre dossier projet, il contient : Bonjour Tous Le Monde !!!

Lire un fichier caractère par caractère et l’afficher à l’écran Exécution: Bonjour Tous Le Monde !!!

Ecrire des caractères dans un fichier import java.io.*; public class EcrireFichier1 { public static void main(String[] args) { Fichier fichier= new Fichier("test1"); try { FileWriter flotEcriture = new FileWriter(fichier); for (char car='a'; car<='z'; ++car) flotEcriture.write (car); flotEcriture.close (); } catch (IOException e) {System.out.println(" erreur :" + e.toString());} } // fin main } // fin classe

Ecrire des caractères dans un fichier Exécution: Le contenu de test1 est : abcdefghijklmnopqrstuvwxyz 10

Classe PrintWriter La classe PrintWriter permet d'écrire sur un flot de sortie des données en les représentant à l'aide de chaînes de caractères, à l'aide des méthodes print et println. import java.io.*; class Ecrire2{ public static void main(String[] argv) throws IOException { FileWriter fichier =new FileWriter ("test"); PrintWriter ecrivain= new PrintWriter (fichier); ecrivain.println ("bonjour, comment cela va-t-il ?"); ecrivain.println ("un peu difficile ?"); ecrivain.println ("On peut mettre des entiers : "+10); ecrivain.println ("Voici un caractère : "+'A'); ecrivain.close(); } }

Classe PrintWriter import java.io.*; class Ecrire2{ Exécution: public static void main(String[] argv) throws IOException { FileWriter fichier =new FileWriter ("test"); PrintWriter ecrivain= new PrintWriter (fichier); ecrivain.println ("bonjour, comment cela va-t-il ?"); ecrivain.println ("un peu difficile ?"); ecrivain.println ("On peut mettre des entiers : "+10); ecrivain.println ("Voici un caractère : "+'A'); ecrivain.close(); }} Exécution: Première exécution de : Ecrire2 Contenu de test : bonjour, comment cela va-t-il ? un peu difficile ? On peut mettre des entiers : 10 Voici un caractère : A FileWriter fichier =new FileWriter ("test",true); Exécution: Deuxième exécution de : Ecrire2 Contenu de test : bonjour, comment cela va-t-il ? un peu difficile ? On peut mettre des entiers : 10 Voici un caractère : A

Classe PrintWriter import java.io.*; Exécution: class Ecrire2{ public static void main(String[] argv) throws IOException { FileWriter fichier =new FileWriter ("test",true); PrintWriter ecrivain= new PrintWriter (fichier); ecrivain.println ("bonjour, comment cela va-t-il ?"); ecrivain.println ("un peu difficile ?"); ecrivain.println ("On peut mettre des entiers : "+10); ecrivain.println ("Voici un caractère : "+'A'); ecrivain.close(); }} Exécution: Après deux exécution de Ecrire2 : Contenu de test : bonjour, comment cela va-t-il ? un peu difficile ? On peut mettre des entiers : 10 Voici un caractère : A

Rechercher un mot dans un fichier import java.io.*; import java.util.Scanner; class find{ public static void rechercher (String mot, File fichier){ String line = null; try { BufferedReader br = new BufferedReader(new FileReader(fichier)); int i = 1; //initialisation du numero de ligne while ((line = br.readLine()) != null) { if ( line.indexOf(mot) != -1) System.out.println("Mot trouve a la ligne " + i ); i++; } br.close(); } catch(IOException ioe) { System.out.println("Erreur IO" ); } } public static void main(String args[]) { System.out.println ("Veuillez saisir un mot :"); Scanner sc = new Scanner (System.in); String str = sc.nextLine(); rechercher (str, new File("find.java")); Exécution : Veuillez saisir un mot : java Mot trouve a la ligne 1 Mot trouve a la ligne 2

Sérialisation

Sérialisation : enregistrer et restaurer des objets La sérialisation est un procédé introduit dans le JDK version 1.1 qui permet de rendre un objet persistant. Un objet est persistant si sa durée de vie est supérieure au programme qui l’a crée. Cet objet est mis sous une forme sous laquelle il pourra être reconstitué à l’identique. Ainsi il pourra être stocké sur un disque dur ou transmis au travers d’un réseau pour le créer dans une autre JVM. C’est le procédé qui est utilisé par exemple, par les sockets pour transmettre un objet via le réseau. Un objet sérialisable est transformable en une suite séquentiel d’octet et inversement, donc peut être stocké dans un fichier.

Serializable est une Interface sans méthode à implémenter. Objet Serializable import java.io.Serializable; class Compte implements Serializable { private String titulaire; private int numeroCompte; private double solde; Compte (String titulaire, int numeroCompte, double solde){ this.titulaire = titulaire; this.numeroCompte = numeroCompte; this.solde = solde; } public String toString (){ return "titulaire : "+ this.titulaire +"\t numeroCompte : "+this.numeroCompte +"\t solde : "+ this.solde; Serializable est une Interface sans méthode à implémenter.

Ecrire des objets dans un fichier import java.io.*; import java.util.*; public class EcrireBanque { public static void main(String[] args) { File fichier= new File("banque"); try { ObjectOutputStream flotEcriture =new ObjectOutputStream(new FileOutputStream(fichier)); ArrayList<Compte> liste=new ArrayList<Compte>(); liste.add(new Compte("aa",1,1000)); liste.add(new Compte("ab",2,2000)); liste.add(new Compte("ac",3,3000)); liste.add(new Compte("ad",4,4000)); flotEcriture.writeObject(liste); flotEcriture.close(); } catch (IOException e) {} }

Exécution Contenu du fichier banque après l’exécution de EcrireBanque : í ♣sr ‼java.util.ArrayListx?Ò↔TÇa?♥ ☺I ♦sizexp ♦w♦ r ♠Compte→¥!7Þt┼à☻ ♥I ♀numeroCompteD ♣soldeL titulairet ↕Ljava/lang/String;xp ☺@?@ t ☻aasq ~ ☻ ☻@Y@ t ☻absq ~ ☻ ♥@§p t ☻acsq ~ ☻ ♦@¯@ t ☻adx

Classe ObjectOuputStream Cette classe permet de sérialiser un objet. On définit un fichier avec la classe FileOutputStream. On instancie un objet de classe ObjectOutputStream en lui fournissant en paramètre le fichier : ainsi, le résultat de la sérialisation sera envoyé dans le fichier. On appelle la méthode writeObject() en lui passant en paramètre l’objet à sérialiser. On appelle la méthode close() pour terminer l’opération. Lors de ces opérations une exception de type IOException peut être levée si un problème intervient avec le fichier. Après l’exécution de cet exemple, un fichier de sauvegarde est créé. On peut visualiser son contenu mais surtout pas le modifier car sinon il serait corrompu. En effet, les données contenues dans ce fichier ne sont pas toutes au format caractères.

Lire des objets dans un fichier import java.io.*; import java.util.*; public class LireBanque { public static void main(String[] args) { File fichier= new File("banque"); try { ObjectInputStream flotLecture = new ObjectInputStream(new FileInputStream(fichier)); Object lu = flotLecture.readObject(); ArrayList liste=(ArrayList)lu; for (int i=0; i<liste.size(); i++) { Object elem = liste.get(i); System.out.println(elem); } flotLecture.close(); } catch (Exception e) {}

Classe ObjectInputStream Cette classe permet de désérialiser un objet. On créer un objet de la classe FileInputStream qui représente le fichier contenant l’objet sérialisé. On créer un objet de type ObjectInputStream en lui passant le fichier en paramètre. Un appel à la méthode readObject() retourne l’objet avec un type Object. Un cast est nécessaire pour obtenir le type de l’objet. La méthode close() permet de terminer l’opération.

Exécution Exécution de LireBanque : titulaire : aa numeroCompte : 1 solde : 1000.0 titulaire : ab numeroCompte : 2 solde : 2000.0 titulaire : ac numeroCompte : 3 solde : 3000.0 titulaire : ad numeroCompte : 4 solde : 4000.0