Java rappels e-s

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


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


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



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


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


filtres


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


Filtres


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


Filtres


DataOutputStreamwriteUTF(String)- writeInt(int)...

PrintStream print() – println()

InputStream

BufferedInputStream

ObjectInputStreamObject readObject()

FileInputStream

Classe abstraite de lecture d’un flot d’octets


Filtres


DataInputStreamreadUTF()- readInt()...


� 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


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


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


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


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;} …

}


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}

}


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}

}

Java rappels e-s

Education

Transcript of Java rappels e-s