1
Rappels Programmation Java
LES ENTREES-SORTIES
Evelyne Vittori [email protected]
Master Informatique
Cours Systèmes Distribués
Rappels JavaLes entrées/Sorties
1. Principe des Entrées-Sorties en java � Comment lire/Ecrire dans un fichier?� Principes des flots d’E/S� Les Flots de Communication� Les Flots Complémentaires ou filtres
2. Sauvegarde d’objets en Java� Lecture/Ecriture d’Objets dans un
fichier de texte� Sérialisation/Désérialisation
3. Gestion des Exceptions
Comment lire/écrire dans un conteneur de données?
� Il faut déclarer et utiliser un ou plusieurs flots(streams)
� Un flot est un objet dans lequel on peut � Lire (flot d’entrée : input )� Écrire (flot de sortie: output )
Programme
……..;
……..;
Fichier, …
écrire
lire
?
Principe des flots d’E/S
� Les flots sont des instances de classes très spécialisées (classes du package java.io).
� Pourquoi?Parce qu’un flot est un objet! Donc, il ne doit faire
qu’une seule chose mais le faire bien!
� Exemples:� Ecrire des octets dans un fichier� Lire des caractères dans un fichier
Un ou plusieurs flots complémentaires: les flots de traitement ou filtres chaînés au flot de communication.
En général, un flot ne suffit pas!
Un flot obligatoire: le flot de communication connecté au fichier (ou à une autre source/destination).
+
Principe des flots d’E/SLe flot obligatoire: le flot de communication
� Un flot de communication représente une connexion avec une source/destination (fichier par exemple).
� Il est spécialisé selon: � La nature des données: octets ou caractères� Le type de source/destination: un fichier, un objet
string, un tableau, etc…� La lecture ou l’écriture
Programme
……..;
……..;
Fichier
écrire
lire
Flot de communication
2
Le flot obligatoire: le flot de communication
Ecrire des caractères dans un fichierFileWriter
Lire des caractères en provenance d’un fichier
FileReader
Ecrire des octets dans un fichierFileOutputStream
Lire des octets en provenance d’un fichier
FileInputStream
RôleClasse
Les flots complémentaires : Les flots de traitement ou filtres
� Un flot de traitement permet de traiter les données (filtrer ou décorer) à l’entrée ou la sortie d’un flot de communication.
� Il est toujours associé (chaîné) à un flot de communication ou à un autre filtre � Son constructeur demande toujours un autre flot en paramètre.
Programme
……..;
……..;
Fichier
écrire
lire
Flot de communicationFiltre
Principe des flots d’E/S
Structure générale du code1. Déclaration du flot (avec éventuellement des filtres)
2. Lecture/ Ecriture dans le flot
3. Fermeture du flot
Filtres
Flot de com.
ClasseFlot monflot = new ClasseFlot(new ClasseFlot2( . . .
new ClassFlot3()));
X= monflot.read();// monflot.write(...)
monflot.close();
Exemple1: Ecriture dans un fichier de texte.
� FileWriter permet de définir un flot de communication pour écrire des caractères dans un fichier
� PrintWriter est un filtre permettant d’écrire directement une chaîne de caractères, un entier, ect...
Principe des flots d’E/S
Les filtres facilitent la programmation!!Ils complètent les méthodes offertes par un flot de communication par des méthodes plus spécialisées
PrintWriter pw = new PrintWriter (new FileWriter ("fichier.txt"),true );
pw. print (“Toto a”); // méthode print(String)pw. print (15); // méthode print(int)pw. print (“ ans”); // méthode print(String)pw. close ();
Exemple1: écriture formatée dans un fichier de texte filtre
Flot decommunication
Principe des flots d’E/SVidage
automatique du flux après
chaque écriture
BufferedReader br = null ; String ligne; br = new BufferedReader ( new
FileReader ( " fichier.txt " )); while ((ligne = br. readLine ()) != null )
System.out.println(ligne); br.close();
Exemple2: lecture avec bufferdans un fichier de texte
filtre
Flot de communication
Principe des flots d’E/S
3
� Exemple3 : Lecture de données de types primitifs dans un fichier d’octets.� FileInputStream permet de définir un flot de
communication pour lire des octets dans un fichier.
� DataInputStream est un filtre permettant de lire directement des types primitifs.
� Méthodes: readInt(), readChar()….
� BufferedInputStream est un filtre permettant l’utilisation d’un buffer pour limiter les accès disques
Principe des flots d’E/S
DataInputStream dis= new DataInputStream (new BufferedInputStream (
new FileInputStream (“fichier”))); System.out.println(dis. readUTF ()); System.out.println(dis. readInt ()); System.out.println(dis. readLong ());
Exemple3: lecture avec buffer dans un fichier binaire
Principe des flots d’E/S
filtres
Flot de communication
Source/destination� Fichier: File� chaîne de caractères : String� tableau d'octets en mémoire:
ByteArray� tableau de caractères en
mémoire:CharArray
préfixe
Dénomination des classes « flots de communication »
suffixeLecture-Ecriture/ Type de données
� Lecture Octets: InputStream� Ecriture Octets: OuputStream� Lecture Caractères: Reader
� Ecriture Caractères: Writer
Classes du package java.io
Type de traitement� Buffered : pour mettre les données d’un flux ( d’entrée ou de sortie)
dans un tampon. � Data : pour lire les octets sous forme de type de données � Object : pour traiter des objets (cf. sérialisation)� InputStream / OuputStream : pour convertir des octets en caractères � Print: pour écrire tous les types de données sous la forme de chaîne
de caractères
préfixe
Dénomination des classes filtres
suffixeReader, Writer, InputStream,
OutputStream
Classes du package java.io
Writer
BufferedWriter
PrintWriterprint(String) – println() -…
flush(): vidage du flux
FileWriter
Classe abstraite d’écriture d’un flot de
caractères
Flot de communication avec un fichier
Filtres
Principales classes du package java.io
OutputStreamWriter
Conversion de caractères en
octets et écriture dans un flot binaire
Reader
BufferedReaderString readLine()
FileReaderint read()
Classe abstraite de lecture d’un flot de
caractères
Flot de communication avec un fichier
Filtres
Principales classes du package java.io
InputStreamReaderLecture dans un flot
binaire et conversion en caractères
4
OutputStream
BufferedOutputStream
ObjectOutputStreamwriteObject(Object)
FileOutputStream
Classe abstraite d’écriture d’un flot
d’octets
Flot de communication avec un fichier
Filtres
Principales classes du package java.io
DataOutputStreamwriteUTF(String)- writeInt(int)...
PrintStream print() – println()
InputStream
BufferedInputStream
ObjectInputStreamObject readObject()
FileInputStream
Classe abstraite de lecture d’un flot d’octets
Flot de communication avec un fichier
Filtres
Principales classes du package java.io
DataInputStreamreadUTF()- readInt()...
Principe des flots d’E/S
� Les flots de communication standards� System.in : objet de type InputStream associé au
clavier
� System.out : objet de type PrintStream associé à la console
BufferedReader entreeClavier = new BufferedReader (
new InputStreamReader( System.in )); System.out .println ("Saisissez une phrase :"); String saisie = entreeClavier. readLine ();
filtres
Entrées/Sorties: Exercice
Définissez un programme qui lit une phrase au clavier dans la console et la sauvegarde dans un fichier de texte.
//Déclaration du flot de lecture au claviermonFSaisie= new
//saisie clavier
//Déclaration du flot d'écriture vers un fichier de texte
monFE=new
//écriture dans le fichier
//fermeture des flots
Les entrées/Sorties
1. Principe des Entrées-Sorties en java � Comment lire/Ecrire dans un fichier?� Principes des flots d’E/S� Les Flots de Communication� Les Flots Complémentaires ou filtres
2. Sauvegarde d’objets en Java� Sérialisation/Désérialisation� Lecture/Ecriture d’Objets dans un
fichier de texte3. Gestion des Exceptions
Comment sauvegarder des objets?
� Si les objets ne sont utilisés que par le programme qui les a créé:� Utiliser la sérialisation
� Si les objets doivent être utilisés par d’autres programmes:� Sauvegarder les objets dans un fichier de texte
5
Sérialisation
� La classe doit implémenter l’interface sérializable (interface vide servant uniquement d’indicateur (flag)).
� Créer un fichier et y sauvegarder les objets compressés (convertis en binaire).
� Le programme pourra ensuite lire les objets sérialisés dans ce fichier et les re-transformer en objets (désérialisation)
Class Personnage implements serializable {private int numero;private String nom;public Personnage(int numero,String nom){
this.numero=numero;this.nom=nom;
}}
Sérialisation
Class Test {public static void main(String[] args) {
Personnage personnageUn=new Personnage(1,”Toto”);
Personnage personnageDeux=new Personnage(1,”Titi”);
. . .}
Pour autoriser la sérialisation
Sérialisation
objet011010010110111001
011010010110111001
fichier
ObjectOutputStream(flot de traitement)
FileOutputStream(flot de communication)
011010010110111001
Transformation en octets
écriture
writeObject
personnageUn
Sérialisation
//1: créer un FileOutputStream
FileOutputStream fos=new FileOutputStream(“MonJeu.ser”));//2: créer un ObjectOutputStream chainé au FileOutputStreamObjectOutputStream oos=new ObjectOutputStream(fos);
//3: Ecrire l’objet dans l’ObjectOutputStreamoos.writeObject(personnageUn);oos.writeObject(personnageDeux);
//4: Fermer l’ObjectOutputStreamoos.close();}
Désérialisation
objet
011010010110111001
011010010110111001
fichier
ObjectInputStream(flot de traitement)
FileInputStream(flot de communication)
011010010110111001
lecture des octets
Transformation en objets
readObject
unP
Désérialisation
//1: créer un FileInputStreamFileInputStream fis=new FileInputStream(“MonJeu.ser”));
//2: créer un ObjectInputStream chainé au FileInputStreamObjectInputStream ois=new ObjectInputStream(fis);
//3: Lire l’objet dans l’ObjectInputStreamPersonnage unP=(Personnage) ois.readObject();Personnage deuxP=(Personnage) ois.readObject();
//4: Fermer l’ObjectInputStreamois.close();}
6
Utilisation d’un fichier de texte
� Sauvegarder les objets dans un fichier de texte: une ligne de texte est écrite pour chaque objet et les valeurs des attributs sont séparées par un délimiteur (virgule, …).
� Utiliser un StringTokenizer pour restaurer les objets
Ecriture dans un fichier de texte
Objet
1, Toto,2,Titi,
1, Toto,2,Titi,
FichierPerso.txt
FileWriter(flot de communication)
Plusieurs écritures
� Ecriture d’un objet par ligne (attributs avec séparateurs) � Utilisation d’un PrintWriter pour formater les écritures.Et d’un BufferedWriter pour limiter les accès disque.
BufferedWriter(filtre)
1, Toto,2,Titi,
1, Toto,2,Titi,
PrintWriter(filtre)
personnageUn
//1: créer un PrintWriter chaîné à un BufferedWriter et un FileWriterPrintWriter pw=new PrintWriter(new
BufferedWriter(new FileWriter(“perso.txt”)),true);
//2: Ecrire les valeurs des attributs dans le BufferedWriterpw.print(personnageUn.getNumero()); //méthode print(int)pw.println(',' +personnageUn.getNom()); //méthode println(String)// la virgule est le séparateur des attributspw.print(personnageDeux.getNumero());pw.println(','+ personnageDeux.getNom());
//3: Fermer le PrintWriterpw.close();
Ecriture dans un fichier de texte
objet
BufferedReader(filtre)
FileReader(flot de communication)
bufferisation
readLine
Lecture dans un fichier de texte
1, Toto,2,Titi,
1, Toto,2,Titi,
FichierPerso.txt
1, Toto, 2,Titi,
String
Construction
unP
//1: créer un BufferedReader chainé avec un FileReaderBufferedReader br=new BufferedReader(new FileReader(“perso.txt”));
//2: lire les lignes dans le BufferedReaderString ligneUnP=br.readLine();String ligneDeuxP=br.readLine();
//3: reconstruire les objetsStringTokenizer st=new StringTokenizer(ligneUnP,“,");unP=new Personnage(Integer.parseInt(st.nextToken()), st.nextToken());st=new StringTokenizer(ligneDeuxP,“,");unP=new Personnage(Integer.parseInt(st.nextToken()), st.nextToken());
//3: Fermer le BufferedReaderbr.close();
Lecture dans un fichier de texte (avec Buffer)
RappelsLes entrées/Sorties
1. Principe des Entrées-Sorties en java � Comment lire/Ecrire dans un fichier?� Principes des flots d’E/S� Les Flots de Communication� Les Flots Complémentaires ou filtres
2. Sauvegarde d’objets en Java� Lecture/Ecriture d’Objets dans un
fichier de texte� Sérialisation/Désérialisation
3. Gestion des Exceptions
7
Principe de gestion des exceptions
� Lorsqu’une erreur se produit dans une méthode, celle-ci crée un objet (exception)qui contient des informations à propos de l’erreur (type, contexte d’exécution, …)
� Les exceptions sont des instances de classes java dont la classe mère est Throwable
Principe de gestion des exceptions
Lancement d’une exception
propagation
traitement
Invocation d’une méthode qui peut lancer une exception
Invocation d’une autre méthode qui peut lancer une exception
try { //instructions qui peuvent provoquer une exception
}
catch (Exception e) { // traitement en cas d’exception
}
finally {// traitement dans tous les cas
}
Instructions de gestion des exceptions
� Une méthode peut attraper (traiter) une exception
Instructions de gestion des exceptions
� Une méthode peut propager une exception sans la traiter:
� Une méthode peut lancer une nouvelle exception:
void m() throws ClassException
throw new ClassException();
Instructions d’un bloc catch(Exception e):
� Affichage d’un message
� Correction de l’erreur� Ecriture de la pile d’appel à l’erreur
� return, break, continue
//Message spécifique//Texte de l’erreurSystem.out.println(e. getMessage ());
e. printStackTrace ();
Instructions de gestion des exceptions
Gestion des exceptions: exemple1
Dépassement d’indice
8
public class Thermometre {private int temperature = 0;public Thermometre() { }public chauffe(int degre) throws MaladeException {
if((temperature + degre) > 40)throw new MaladeException();
temperature += degre;}public baisse(int degre) {
temperature -= degre;} …
}
Gestion des exceptions: exemple2
Lancement d’une exception
personnalisée
public class Thermometre {…class MaladeException extends Exception {
MaladeException() {super();
}}
public static void main(String[] args) {Thermometre th = new Thermometre();try {
th.chauffe(38);} catch(MaladeException e) {
// Faire quelque chose}
}
Gestion des exceptions: exemple2
Invocation d’une méthode susceptible de lancer une exception
Les exceptions liées aux flots I/O
Erreur d’E/S= java.io.IOException� EOFException : lecture de la fin de fichier� FileNotFoundedException : fichier
inexistant� InterruptedIOException : opération
d’entrée /sortie interrompue� ObjectStreamException : problème pendant
la sérialisation
Structure générale du code de contrôle des exceptions d’E/S
FlotES monFlot= null; //Déclaration d’un flottry { //Ouverture du flot
//Instructions de lecture/écriture}catch( IOException ioe){
// Instructions de traitement des erreurs}finally {
try { //Fermeture du flotif (monFlot!=null) monflot.close();
}catch( IOException ioe ){
// traitement de l’erreur de fermeture}
}
Top Related