Cours Java très détaillé

1. Rappels Java
Master Informatique
Les entrées/Sorties
Cours Systèmes Distribués
1. Principe des Entrées-Sorties en java
Rappels Programmation Java Comment lire/Ecrire dans un fichier?
Principes des flots d’E/S
Les Flots de Communication
LES ENTREES-SORTIES 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
Evelyne Vittori 3. Gestion des Exceptions
vittori@univ-corse.fr
Comment lire/écrire dans un
conteneur de données? Principe des flots d’E/S
écrire
……
……
..;
? ..;
Fichier, …
Les flots sont des instances de classes très
Programme spécialisées (classes du package java.io).
lire
Il faut déclarer et utiliser un ou plusieurs flots Pourquoi?
(streams) Parce qu’un flot est un objet! Donc, il ne doit faire
qu’une seule chose mais le faire bien!
Un flot est un objet dans lequel on peut
Exemples:
Lire (flot d’entrée : input )
Ecrire des octets dans un fichier
Écrire (flot de sortie: output )
Lire des caractères dans un fichier
Le flot obligatoire: le flot de
Principe des flots d’E/S communication
écrire
Flot de ……
En général, un flot ne suffit pas! communication
……
..;
..;
Fichier
Programme lire
Un flot obligatoire: le flot de
Un flot de communication représente une connexion
communication connecté au fichier avec une source/destination (fichier par exemple).
(ou à une autre source/destination).
Il est spécialisé selon:
+ La nature des données: octets ou caractères
Un ou plusieurs flots complémentaires: les Le type de source/destination: un fichier, un objet
flots de traitement ou filtres chaînés au flot de string, un tableau, etc…
communication. La lecture ou l’écriture
1

2. Le flot obligatoire: le flot de Les flots complémentaires : Les
communication flots de traitement ou filtres
écrire
Flot de ……
Classe Rôle Filtre ……
..;
communication ..;
Fichier
FileInputStream Lire des octets en provenance d’un Programme
fichier
lire
FileOutputStream Ecrire des octets dans un fichier Un flot de traitement permet de traiter les
Lire des caractères en provenance
données (filtrer ou décorer) à l’entrée ou la sortie
FileReader d’un flot de communication.
d’un fichier
FileWriter Ecrire des caractères dans un fichier Il est toujours associé (chaîné) à un flot de
communication ou à un autre filtre
Son constructeur demande toujours un autre flot en
paramètre.
Principe des flots d’E/S Principe des flots d’E/S
Structure générale du code Exemple1: Ecriture dans un fichier de texte.
1. Déclaration du flot (avec éventuellement des filtres) FileWriter permet de définir un flot de
ClasseFlot monflot= new ClasseFlot(
communication pour écrire des caractères dans
Filtres new ClasseFlot2( . . . un fichier
new ClassFlot3()));
PrintWriter est un filtre permettant d’écrire
Flot de com. directement une chaîne de caractères, un entier,
2. Lecture/ Ecriture dans le flot ect...
X= monflot.read();// monflot.write(...)
Les filtres facilitent la programmation!!
3. Fermeture du flot Ils complètent les méthodes offertes par un flot de
monflot.close(); communication par des méthodes plus spécialisées
Principe des flots d’E/S Principe des flots d’E/S
Vidage
automatique
Exemple1: écriture formatée dans un du flux après
Exemple2: lecture avec buffer
fichier de texte filtre
chaque filtre
écriture dans un fichier de texte
PrintWriter pw = new PrintWriter( BufferedReader br = null; String ligne;
new FileWriter("fichier.txt"),true ); br = new BufferedReader (new
pw.print(“Toto a”); //méthode print(String) FileReader("fichier.txt"));
pw.print(15); //méthode print(int) while ((ligne = br.readLine()) != null)
pw.print(“ ans”); //méthode print(String) System.out.println(ligne);
pw.close(); br.close();
Flot de Flot de
communication communication
2

3. Principe des flots d’E/S Principe des flots d’E/S
Exemple3 : Lecture de données de types primitifs Exemple3: lecture avec buffer dans un fichier
dans un fichier d’octets. binaire filtres
FileInputStream permet de définir un flot de
communication pour lire des octets dans un fichier. DataInputStream dis= new DataInputStream(
DataInputStream est un filtre permettant de lire new BufferedInputStream (
directement des types primitifs. new FileInputStream(“fichier”)));
Méthodes: readInt(), readChar()…. System.out.println(dis.readUTF());
BufferedInputStream est un filtre permettant System.out.println(dis.readInt());
l’utilisation d’un buffer pour limiter les accès disques System.out.println(dis.readLong());
Flot de communication
Classes du package java.io Classes du package java.io
Dénomination des classes « flots de communication » Dénomination des classes filtres
préfixe suffixe préfixe suffixe Reader, Writer, InputStream,
Lecture-Ecriture/ Type OutputStream
Type de traitement
Source/destination de données Buffered : pour mettre les données d’un flux ( d’entrée ou de sortie)
Fichier: File Lecture Octets: InputStream dans un tampon.
Data : pour lire les octets sous forme de type de données
chaîne de caractères : String Ecriture Octets: OuputStream
Object : pour traiter des objets (cf. sérialisation)
tableau d'octets en mémoire: Lecture Caractères: Reader InputStream / OuputStream : pour convertir des octets en caractères
ByteArray Ecriture Caractères: Writer Print: pour écrire tous les types de données sous la forme de chaîne
de caractères
tableau de caractères en
mémoire:CharArray
Principales classes du package Principales classes du package
java.io java.io
Classe abstraite
d’écriture d’un flot de Classe abstraite de
caractères lecture d’un flot de
Writer caractères
Reader
FileWriter Flot de communication
avec un fichier FileReader Flot de communication
avec un fichier
BufferedWriter int read()
Filtres
PrintWriter BufferedReader Filtres
print(String) – println() -… String readLine()
Conversion de
flush():vidage du flux caractères en Lecture dans un flot
binaire et conversion en
octets et écriture InputStreamReader caractères
OutputStreamWriter dans un flot binaire
3

4. Principales classes du package Principales classes du package
java.io Classe abstraite
java.io
OutputStream d’écriture d’un flot Classe abstraite de
d’octets lecture d’un flot d’octets
FileOutputStream Flot de
InputStream
communication Flot de communication
BufferedOutputStream avec un fichier FileInputStream avec un fichier
ObjectOutputStream Filtres ObjectInputStream
writeObject(Object) Object readObject()
Filtres
DataOutputStream BufferedInputStream
writeUTF(String)- writeInt(int)...
DataInputStream
PrintStream print() – println() readUTF()- readInt()...
Principe des flots d’E/S Entrées/Sorties: Exercice
Les flots de communication standards Définissez un programme qui lit une phrase au
System.in : objet de type InputStream associé au clavier dans la console et la sauvegarde dans
clavier un fichier de texte.
//Déclaration du flot de lecture au clavier
BufferedReader entreeClavier =
monFSaisie=new
filtres new BufferedReader(
new InputStreamReader(System.in));
//saisie clavier
System.out.println ("Saisissez une phrase :"); //Déclaration du flot d'écriture vers un fichier de
String saisie = entreeClavier.readLine(); texte
monFE=new
System.out : objet de type PrintStream associé à la //écriture dans le fichier
console //fermeture des flots
Comment sauvegarder des
Les entrées/Sorties objets?
1. Principe des Entrées-Sorties en java Si les objets ne sont utilisés que par le
Comment lire/Ecrire dans un fichier? programme qui les a créé:
Principes des flots d’E/S Utiliser la sérialisation
Les Flots de Communication
Les Flots Complémentaires ou filtres
2. Sauvegarde d’objets en Java Si les objets doivent être utilisés par d’autres
Sérialisation/Désérialisation programmes:
Lecture/Ecriture d’Objets dans un Sauvegarder les objets dans un fichier de texte
fichier de texte
3. Gestion des Exceptions
4

5. Pour autoriser la
Sérialisation sérialisation
Sérialisation
Class Personnage implements serializable {
private int numero;
La classe doit implémenter l’interface private String nom;
sérializable (interface vide servant uniquement public Personnage(int numero,String nom){
d’indicateur (flag)). this.numero=numero;
this.nom=nom;
}
Créer un fichier et y sauvegarder les objets } Class Test {
compressés (convertis en binaire). public static void main(String[] args) {
Personnage personnageUn=new
Personnage(1,”Toto”);
Le programme pourra ensuite lire les objets Personnage personnageDeux=new
sérialisés dans ce fichier et les re-transformer Personnage(1,”Titi”);
en objets (désérialisation) }
. . .
Sérialisation Sérialisation
writeObject //1: créer un FileOutputStream
FileOutputStream fos=new FileOutputStream(“MonJeu.ser”));
//2: créer un ObjectOutputStream chainé au
Transformation 011010
011010 FileOutputStream
en octets
objet ObjectOutputStream
(flot de traitement)
010110
010110 ObjectOutputStream oos=new ObjectOutputStream(fos);
personnageUn écriture 111001
111001 //3: Ecrire l’objet dans l’ObjectOutputStream
oos.writeObject(personnageUn);
011010010110111001 fichier oos.writeObject(personnageDeux);
FileOutputStream
(flot de communication) //4: Fermer l’ObjectOutputStream
oos.close();
}
Désérialisation Désérialisation
//1: créer un FileInputStream
lecture des octets
011010 FileInputStream fis=new FileInputStream(“MonJeu.ser”));
011010
010110
010110 011010010110111001
111001
111001 Transformation en //2: créer un ObjectInputStream chainé au FileInputStream
FileInputStream ObjectInputStream ois=new ObjectInputStream(fis);
(flot de communication) objets
fichier
//3: Lire l’objet dans l’ObjectInputStream
Personnage unP=(Personnage) ois.readObject();
ObjectInputStream
unP Personnage deuxP=(Personnage) ois.readObject();
(flot de traitement)
//4: Fermer l’ObjectInputStream
readObject ois.close();
objet }
5

6. Utilisation d’un fichier de texte Ecriture dans un fichier de texte
BufferedWriter
Sauvegarder les objets dans un fichier de Plusieurs (filtre)
1, Toto, 1, Toto,
texte: une ligne de texte est écrite pour écritures 2,Titi,
2,Titi,
chaque objet et les valeurs des attributs sont PrintWriter 1, Toto,
1, Toto,
séparées par un délimiteur (virgule, …). (filtre) 2,Titi,
2,Titi,
Objet
Utiliser un StringTokenizer pour restaurer les personnageUn FileWriter Fichier
(flot de communication)
Perso.txt
objets 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.
Ecriture dans un fichier de Lecture dans un fichier de
texte texte
//1: créer un PrintWriter chaîné à un BufferedWriter et un
FileWriter 1, Toto,
PrintWriter pw=new PrintWriter(new 1, Toto,
1, Toto,
BufferedWriter(new FileWriter(“perso.txt”)),true); 2,Titi,
2,Titi, 2,Titi,
FileReader bufferisation
//2: Ecrire les valeurs des attributs dans le BufferedWriter (flot de communication)
pw.print(personnageUn.getNumero()); //méthode print(int) Fichier
pw.println(',' +personnageUn.getNom()); //méthode println(String) Perso.txt
// la virgule est le séparateur des attributs
pw.print(personnageDeux.getNumero());
BufferedReader
Construction
pw.println(','+ personnageDeux.getNom());
(filtre)
//3: Fermer le PrintWriter readLine unP
pw.close();
String objet
Lecture dans un fichier de Rappels
texte (avec Buffer) Les entrées/Sorties
//1: créer un BufferedReader chainé avec un FileReader
BufferedReader br=new BufferedReader(new FileReader(“perso.txt”)); 1. Principe des Entrées-Sorties en java
//2: lire les lignes dans le BufferedReader Comment lire/Ecrire dans un fichier?
String ligneUnP=br.readLine(); Principes des flots d’E/S
String ligneDeuxP=br.readLine(); Les Flots de Communication
Les Flots Complémentaires ou filtres
//3: reconstruire les objets
StringTokenizer st=new StringTokenizer(ligneUnP,“,"); 2. Sauvegarde d’objets en Java
unP=new Personnage(Integer.parseInt(st.nextToken()), st.nextToken()); Lecture/Ecriture d’Objets dans un
st=new StringTokenizer(ligneDeuxP,“,");
unP=new Personnage(Integer.parseInt(st.nextToken()), st.nextToken());
fichier de texte
Sérialisation/Désérialisation
//3: Fermer le BufferedReader 3. Gestion des Exceptions
br.close();
6

7. Principe de gestion des Principe de gestion des
exceptions exceptions
Lorsqu’une erreur se produit dans une
Invocation d’une méthode qui peut lancer une exception
méthode, celle-ci crée un objet (exception)
qui contient des informations à propos de Invocation d’une autre
méthode qui peut lancer
l’erreur (type, contexte d’exécution, …) une exception
Les exceptions sont des instances de classes traitement
java dont la classe mère est Throwable
propagation
Lancement
d’une exception
Instructions de gestion des Instructions de gestion des
exceptions exceptions
Une méthode peut attraper (traiter) une Une méthode peut propager une exception
exception sans la traiter:
try {
//instructions qui peuvent provoquer void m() throws ClassException
une exception
} Une méthode peut lancer une nouvelle
catch (Exception e) {
exception:
// traitement en cas d’exception
} throw new ClassException();
finally {
// traitement dans tous les cas
}
Instructions de gestion des Gestion des exceptions:
exceptions exemple1
Instructions d’un bloc catch(Exception e):
Affichage d’un message Dépassement d’indice
//Message spécifique
//Texte de l’erreur
System.out.println(e.getMessage());
Correction de l’erreur
Ecriture de la pile d’appel à l’erreur
e.printStackTrace();
return, break, continue
7

8. Gestion des exceptions: Gestion des exceptions:
exemple2 exemple2
public class Thermometre {
public class Thermometre {
private int temperature = 0;
…
public Thermometre() { } class MaladeException extends Exception {
public chauffe(int degre) throws MaladeException { MaladeException() {
super();
if((temperature + degre) > 40) }
throw new MaladeException(); }
Invocation d’une méthode
temperature += degre; public static void main(String[] args) { susceptible de lancer une
} Lancement d’une Thermometre th = new Thermometre(); exception
try {
public baisse(int degre) { exception th.chauffe(38);
temperature -= degre; personnalisée } catch(MaladeException e) {
// Faire quelque chose
} … }
} }
Structure générale du code de
Les exceptions liées aux flots I/O contrôle des exceptions d’E/S
FlotES monFlot= null; //Déclaration d’un flot
Erreur d’E/S= java.io.IOException try{ //Ouverture du flot
//Instructions de lecture/écriture
EOFException : lecture de la fin de fichier }
FileNotFoundedException : fichier catch(IOException ioe){
// Instructions de traitement des erreurs
inexistant }
InterruptedIOException : opération finally{
try{ //Fermeture du flot
d’entrée /sortie interrompue if (monFlot!=null) monflot.close();
}
ObjectStreamException : problème pendant catch(IOException ioe){
la sérialisation // traitement de l’erreur de fermeture
}
}
8