Flux d'entrée / sortie
API pour les flux
* Deux bibliothèques fournies en standard
* Elles sont complémentaires
* java.io
* Flux de données
* Classes "InputStream" et "OutputStream"
* Système de fichiers
* Classe "File"
* Sérialisation
* Interfaces "Serializable" et "Externalizable"
* java.nio
* Hautes performances
* Destiné à un volume important d'E/S
Flux de sortie
Sortie texte (1/2)
* Sortie texte modélisée par "PrintStream"
* Exemple: System.out
* Sortie terminal
* Création d'un fichier de sortie
* fic = new FileOutputStream("sortie.txt");
* Construction d'un flux texte à partir d'un fichier
* flux = new PrintStream(fic);
* Fermeture du fichier avec la méthode "close"
Sortie texte (2/2)
* Ecriture dans un flux texte
* Avec les méthodes "print" et "println"
* Paramètre = objet "String"
* Conversion implicite des types primitifs
* Conversion par la méthode "toString" pour les classes
* Méthode définie initialement dans "Object"
* Redéfinie pour retourner une forme texte de l'objet
* Exemple
flux.println("Hello !");
flux.println(new Date());
flux.println(5);
fic.close();
Sortie binaire
* Sortie binaire modélisée par "DataOutputStream"
* Construction d'un flux binaire à partir d'un fichier
* fic = new FileOutputStream("sortie.dat");
flux = new DataOutputStream(fic);
* Ecriture dans un flux binaire
* Seulement pour les types primitifs
* writeBoolean, writeByte, writeChar, writeDouble, writeInt...
* Pour les chaînes: writeChars
* Exemples
* flux.writeDouble(3.5);
* flux.writeChars("hello !");
* A suivre: la sérialisation
* Mémorisation de l'état d'un objet
Flux d'entrée
Entrée texte (1/3)
* Flux d'entrée modélisé par "InputStream"
* Exemple: System.in
* Entrée clavier
* Création d'un fichier d'entrée
* fic = new FileInputStream("entree.txt");
* Construction d'un flux caractère par caractère à partir d'un fichier
* fcar = new InputStreamReader(fic);
* Construction d'un flux caractère par caractère à partir du clavier
* fcar = new InputStreamReader(System.in);
* Construction d'un flux texte item par item
* A partir du flux caractère par caractère
* flux = new StreamTokenizer(fcar);
Entrée texte (2/3)
* Parcours des items: méthode "nextToken"
* Se place sur le prochain item
* Doit être appelée au départ pour se placer sur le premier item
* Par défaut, séparateur = espace + caractères de contrôle
* Réglage avec les méthodes "whitespaceChars" et "wordChars"
* Retourne le type de l'item pointé
* TT_NUMBER = nombre
* TT_WORD = chaîne de caractères
* TT_EOF = fin de fichier
* Lecture de l'information: attributs "nval" et "sval"
* Attributs du flux
* Contiennent l'item pointé
* nval = item sous forme de "double"
* sval = item sous forme de "String"
Entrée texte (3/3)
* Exemple: détection du type de l'item
double d; String s;
int type = flux.nextToken();
if (type == StreamTokenizer.TT_NUMBER)
d = flux.nval;
else if (type == StreamTokenizer.TT_WORD)
s = flux.sval;
* Exemple: parcours jusqu'à la fin du flux
int i;
while (flux.nextToken() != StreamTokenizer.TT_EOF) {
i = (int)flux.nval;
System.out.println(i);
}
Entrée binaire
* Entrée binaire modélisée par "DataInputStream"
* Construction d'un flux binaire à partir d'un fichier
* fic = new FileInputStream("entree.dat");
flux = new DataInputStream(fic);
* Lecture dans un flux binaire
* Seulement pour les types primitifs
* readBoolean, readByte, readChar, readDouble, readInt...
* Détection de la fin du flux: méthode "available"
* Retourne le nombre d'octets encore disponibles
* Exemple
double d;
while (flux.available() != 0) {
d = flux.readDouble();
System.out.println(d);
}
Sérialisation
* Sérialisation = rendre un objet persistent
* Persistence = capacité à survivre à l'exécution d'un programme
* L'objet peut être rechargé lors d'une exécution ultérieure
* Gestion du problème des références / pointeurs
* Enregistrement de l'état d'un objet dans un fichier
* Objet sérialisable ==> sa classe implémente "Serializable"
* class Personne implements Serializable { ... }
* Gestion automatique par Java
* Aucune méthode n'est définie dans l'interface
* Permet simplement d'activer le mécanisme sur une classe
* Tentative de sérialisation d'un objet non sérialisable
* Exception "NotSerializableException" levée
Sortie sérialisée
* Sortie sérialisée modélisée par "ObjectOutputStream"
* Construction d'un flux sérialisé à partir d'un fichier
* fic = new FileOutputStream("perso.ser");
flux = new ObjectOutputStream(fic);
* Enregistrement d'un objet: méthode "writeObject"
* Personne p = new Personne("Nawouak","Bruno");
* flux.writeObject(p);
* Tous les attributs de l'objet enregistrés dans le flux
* Agrégation totalement gérée ==> sérialisation en chaîne
* Gestion automatique de la persistence des références
* Possibilité de sérialiser des éléments de type primitif
* Identique à la classe "DataOutputStream"
* writeBoolean, writeByte, writeChar, writeDouble, writeInt...
Entrée sérialisée
* Entrée sérialisée modélisée par "ObjectInputStream"
* Construction d'un flux sérialisé à partir d'un fichier
* fic = new FileInputStream("perso.ser");
flux = new ObjectInputStream(fic);
* Lecture d'un objet: méthode "readObject"
* Personne p = (Personne)flux.readObject();
* Objet créé par la méthode ==> pas d'appel à un constructeur
* Possibilité de désérialiser des éléments de type primitif
* Identique à la classe "DataInputStream"
* readBoolean, readByte, readChar, readDouble, readInt...
* Problème: classe modifiée entre sérialisation et désérialisation
* Exception "InvalidClassException" levée
* Sous certaines conditions la désérialisation est toujours possible
* En forçant l'ID de version de la classe ==> attribut "serialVersionUID"
Contrôle de la sérialisation
* Empêcher la sérialisation: mot-clé "transient"
* Sécurité ==> éviter l'enregistrement de certaines données
* A placer dans la déclaration des attributs non sérialisés
* private transient String codeSecret;
* Désérialisation ==> "null" dans les attributs "transient"
* Sérialisation personnalisée
* Implémentation de l'interface "Externalizable"
* Qui hérite de l'interface "Serializable"
* Seule l'identité de la classe est gérée automatiquement
* Par défaut, aucun attribut n'est sérialisé
* Donc, mot-clé "transient" inutile
* Méthodes de sérialisation et désérialisation
* readExternal(:ObjectInputStream)
* writeExternal(:ObjectOutputStream)