cours_introd_rsd_reparti_2016

Master Réseaux et Systèmes Distribués (RSD)
Algorithmique des systèmes
et applications réparties (pré requis)
Badr Benmammar
[email protected]
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
2
Gestion des fichiers
3
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());
}
}
4
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.
5
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.
6
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");
Le fichier test se trouve dans
votre dossier projet, il contient :
try { FileReader flotLecture = new FileReader (fichier);
long longueurFichier= fichier.length();
Bonjour
int dejaLu = 0;
Tous
char car=0;
Le
while (dejaLu < longueurFichier) {
Monde !!!
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
7
} // fin classe
Lire un fichier caractère par caractère
et l’afficher à l’écran
Exécution:
Bonjour
Tous
Le
Monde !!!
8
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
9
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(); }
{
}
11
Classe PrintWriter
import java.io.*;
Exécution:
class Ecrire2{
Première exécution de : Ecrire2
public static void main(String[] argv) throws IOException {
Contenu
de test("test",true);
:
FileWriter fichier =new
("test");
FileWriter
comment (fichier);
cela va-t-il ?
PrintWriter ecrivain=bonjour,
new PrintWriter
un peu
difficilecela
? va-t-il ?");
ecrivain.println ("bonjour,
comment
Ondifficile
peut mettre
ecrivain.println ("un peu
?"); des entiers : 10
Voicimettre
un caractère
: A : "+10);
ecrivain.println ("On peut
des entiers
ecrivain.println ("Voici un caractère : "+'A');
ecrivain.close(); }} 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
12
Classe PrintWriter
Exécution:
import java.io.*;
class Ecrire2{
Après deux exécution de Ecrire2 :
public static void main(String[] argv) throws IOException {
Contenu de test :
FileWriter fichier =new FileWriter ("test",true);
bonjour, comment cela va-t-il ?
PrintWriter ecrivain= new PrintWriter (fichier);
un peu difficile ?
ecrivain.println ("bonjour, comment cela va-t-il ?");
On peut mettre des entiers : 10
ecrivain.println ("un peu difficile ?");
Voici un caractère : A
ecrivain.println ("On peut mettre des entiers : "+10);
bonjour, comment cela va-t-il ?
ecrivain.println ("Voici un caractère : "+'A');
un peu difficile ?
ecrivain.close(); }}
On peut mettre des entiers : 10
Voici un caractère : A
13
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
14
Sérialisation
15
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.
16
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.
17
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) {}
}
}
18
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
19
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.
20
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) {}
}
}
21
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.
22
Exécution
Exécution de LireBanque :
titulaire : aa
titulaire : ab
titulaire : ac
titulaire : ad
numeroCompte : 1
numeroCompte : 2
numeroCompte : 3
numeroCompte : 4
solde : 1000.0
solde : 2000.0
solde : 3000.0
solde : 4000.0
23