LANGAGE JAVA
LES ENTREES / SORTIES
1 Généralités sur les flots de données
Les flots de données permettent la gestion des opérations de lecture et d'écriture sur ou vers
des sources différentes.
Il existe quatre classes principales permettant de traiter les flots :
Flots d'octets
- InputStream
- OutputStream
Flots de caractères
- Reader
- Writer
Les noms des classes de flux (Héritant des classes abstraites InputStream, OutputStream,
Reader et Writer) se comprennent assez aisément si l'on utilise ces termes comme suffixe
permettant de déterminer la nature du flux. Pour la source ou la destination, on utilise les
préfixes suivants :
Source ou Destination Préfixe
Chaîne de caractères String
Fichier File
Flux d'octets InputStream ou OutputStream
Exemple
StringWriter (Héritant de la classe Writer) : flux de caractères en écritures, crée à partir d'une
chaîne de caractères.
FileInputStream (Héritant de la classe InputStream): flux d'octets en lecture, crée à partir d'un
fichier.
InputStreamReader (Héritant de la classe Reader): flux de caractères en lecture construits à
partir d'un flux d'octets.
2 Saisir des données envoyées par le clavier
Pour saisir les données envoyées par le clavier on utilise généralement deux classes
appartenant au paquetage [Link] : InputStreamReader et BufferedReader (flux de
caractères en lecture construit à partir d'un Buffer).
Remarque
On utilise la classe BufferedReader car elle contient une méthode readLine( ) permettant la
lecture d'une chaîne de caractère. Avec la classe InputStreamReader on ne peut lire des
caractères qu'un par un.
M. BOUAABID Mourad 1
LANGAGE JAVA
2.1 Construction d'objets BufferedReader et InputStreamReader
BufferedReader a un constructeur qui prend en argument une instance de Reader (dont hérite
InputStreamReader). InputStreamReader admet quant à elle un constructeur ayant comme
argument un flot d'entrée (le flot d'entrée sur clavier est désigné par [Link]).
2.2 Exemple de lecture à partir du clavier
String ligne;
BufferedReader fluxEntree = new BufferedReader( new InputStreamReader([Link]));
ligne = [Link]( );
Remarques!!
- La méthode readLine( ) lance une exception du type IOException(Input Output
Exception) qu'il faudra gérer.
- Pour pouvoir lire des types doubles, int,…il faudra utiliser la méthode readLine( ) pour lire
des caractères et faire un cast avec les méthodes valueOf( ) et doubleValue( )…
Exemple complet
import [Link].*;
class Saisie
{
public static void main(String[] arg)
{
String ligne;
double x;
BufferReader entree = new BufferedReader (new InputStreamReader([Link]));
try{
ligne = [Link]( );
x = [Link](entree).doubleValue( );
[Link](x);
}
catch(Exception e){
[Link]("Erreur de lecture");
[Link](1);
}
}
}
3 Lire ou écrire des caractères dans un fichier
La classe FileReader permet de lire des caractères dans un fichier. Cette classe contient un
constructeur qui a comme argument une chaîne de caractères représentant le nom du fichier.
La classe FileWriter permet d'écrire des caractères dans un fichier. Cette classe contient un
constructeur qui a comme argument une chaîne de caractères représentant le nom du fichier.
M. BOUAABID Mourad 2
LANGAGE JAVA
Exemple
Supposons que l'on veuille écrire un programme permettant d'écrire une chaîne de caractères
dans un fichier nommé [Link] puis copier le fichier [Link] caractère par caractère
dans notre fichier [Link].
Nous allons utiliser pour cela les deux classes FileReader et FileWriter
import [Link].*;
class LireEcrireTexte
{
public static void main(String arg[]) throws IOException
{
FileReader lecteur;
FileWriter ecrivain;
int c;
lecteur = new FileReader("[Link]");
ecrivain = new FileWriter("[Link]");
[Link]("on essaye de faire une copie");
while( (c = [Link]( ) ! = -1 ) [Link](c);
[Link]( );
[Link]( );
}
}
Remarque
La méthode read( ) renvoie –1 si on est en fin de flux
4 Ecrire et lire dans un fichier texte
4.1 Ecrire dans un fichier texte
Pour écrire dans un fichier texte (on écrit des chaînes caractères et plus des caractères
seulement), on utilise généralement la classe PrintWriter pour pouvoir utiliser la méthode
println(String) de la même façon qu'avec [Link]. La classe PrintWriter possède un
constructeur qui a comme argument un objet Writer.
Exemple
import [Link].*;
class EcrireFichierTexte
{
public static void main(String arg[]) throws IOException
{
int n = 5;
PrintWriter ecrivain = new PrintWriter(new BufferedWriter( new FileWriter(arg[0])));
[Link]("Bonjour");
M. BOUAABID Mourad 3
LANGAGE JAVA
[Link](n);
[Link](new Integer(36));
[Link]( );
}
}
Remarque
On aurait pu plus simplement initialiser ecrivain par: ecrivain = new PrintWriter(new
FileWriter(arg[0])); mais alors les écritures n'utiliseraient pas de mémoire-tampon.
4.2 Lecture dans un fichier texte
Pour pouvoir lire des chaînes de caractères à partir d'un fichier on utilise généralement la
classe BufferedReader. La classe dispose d'un constructeur qui admet comme argument un
objet de type Reader (On utilise généralement un objet FileReader).
Exemple
import [Link].*;
class lireLigne
{
public static void main(String[] arg) throws IOException
{
BufferedReader lecteurAvecBuffer = null;
String ligne;
try
{
lecteurAvecBuffer = new BufferedReader(new FileReader(arg[0]));
}
catch (FileNotFoundException e)
{
[Link]("Erreur d'ouverture");
}
while ( (ligne = [Link]( ) ) ! = null) [Link](ligne);
[Link]( );
}
}
Application1 : Lecture d’un fichier texte caractère par caractère avec un affichage sur une
zone texte.
M. BOUAABID Mourad 4
LANGAGE JAVA
private void lire1ActionPerformed([Link] evt) {
try{
FileReader l;
int c;
l = new FileReader([Link]("[Link]")+"\\src\\affthreads\\data");
while( (c = [Link]()) != -1 )
[Link]([Link]()+(char)c);
[Link]( );
}catch(IOException ex){
[Link](null, [Link]());
}
}
private void lire2ActionPerformed([Link] evt) {
BufferedReader l = null;
String ligne;
try
{
l = new BufferedReader(new
FileReader([Link]("[Link]")+"\\src\\affthreads\\data"));
while ((ligne = [Link]() ) != null)
[Link]([Link]()+ligne+"\n");
}
M. BOUAABID Mourad 5
LANGAGE JAVA
catch (IOException e)
{
[Link](null, [Link]());
}
}
5 Fichier d’objet
5.1 Sérialisation des objets
La sérialisation est un procédé introduit dans le JDK version 1.1 qui permet de rendre un
objet persistant. 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 RMI. La sérialisation est
aussi utilisée par les beans pour sauvegarder leurs états.
Au travers de ce mécanisme, Java fourni une façon facile, transparente et standard de réaliser
cette opération : ceci permet de facilement mettre en place un mécanisme de persistance. Il est
de ce fait inutile de créer un format particulier pour sauvegarder et relire un objet. Le format
utilisé est indépendant du système d'exploitation. Ainsi, un objet sérialisé sur un système peut
être réutilisé par un autre système pour récréer l'objet.
L'ajout d'un attribut à l'objet est automatiquement pris en compte lors de la sérialisation.
Attention toutefois, la déserialisation de l'objet doit se faire avec la classe qui a été utilisée
pour la sérialisation.
La sérialisation peut s'appliquer facilement à tous les objets.
5.2 Interface Serializable
Cette interface ne définit aucune méthode mais permet simplement de marquer une classe comme
pouvant être sérialisée.
Tout objet qui doit être sérialisé doit implémenter cette interface ou une de ses classes mères doit
l'implémenter.
Si l'on tente de sérialiser un objet qui n'implémente pas l'interface Serializable, une exception
NotSerializableException est levée.
import [Link].*;
public class Personne implements Serializable
{
private String nom, prenom = "";
private int age;
public Personne(String nom, String prenom, int age)
{ [Link] = nom; [Link] = age;
[Link] = prenom; }
public String getNom() { return nom; }
public void setNom(String nom) { [Link] = nom; }
public int getAge() { return age; }
public void setAge(int age) { [Link] = age; }
M. BOUAABID Mourad 6
LANGAGE JAVA
public String getPrenom() { return prenom; }
public void setPrenom(String prenom) { [Link] = prenom;}
}
5.3 Classe ObjectOutputStream
Cette classe permet de sérialiser un objet.
import [Link].*;
public class SerializerPersonne {
public static void main(String argv[ ]) {
Personne personne = new Personne("Dupond","Jean",25);
try {
FileOutputStream fichier = new FileOutputStream("[Link]");
ObjectOutputStream oos = new ObjectOutputStream(fichier);
[Link](personne);
[Link]();
[Link]();
}
catch (IOException e) {
[Link]();
}
}
.}
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.
M. BOUAABID Mourad 7
LANGAGE JAVA
On appelle la méthode writeObject() en lui passant en paramètre l'objet à sérialiser. On appelle la
méthode flush() pour vider le tampon dans le fichier et 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 nommé « [Link] » 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.
La classe ObjectOutputStream contient aussi plusieurs méthodes qui permettent de sérialiser des
types élémentaires et non des objets : writeInt(), writeDouble(), writeFloat(), ...
Il est possible dans un même flux d'écrire plusieurs objets les uns à la suite des autres. Ainsi
plusieurs objets peuvent être sauvegardés. Dans ce cas, il faut faire attention de relire les objets
dans leur ordre d'écriture.
5.4 Classe ObjectInputStream
Cette classe permet de désérialiser un objet.
import [Link].*;
public class DeSerializerPersonne {
public static void main(String argv[]) {
try {
FileInputStream fichier = new FileInputStream("[Link]");
ObjectInputStream ois = new ObjectInputStream(fichier);
Personne personne = (Personne) [Link]();
[Link]("Personne : ");
[Link]("nom : "+[Link]());
[Link]("prenom : "+[Link]());
[Link]("Age : "+[Link]());
}
catch ([Link] e) {
[Link]();
}
catch (ClassNotFoundException e) {
[Link]();
}
}
}
Résultat:
nom : Dupond
prenom : Jean
Age : 24
On créée un objet de la classe FileInputStream qui représente le fichier contenant l'objet sérialisé
puis 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.
Si la classe a changé entre le moment où elle a été sérialisée et le moment où elle est désérialisée,
une exception est levée.
Une exception de type ClassNotFoundException peut être levée si l'objet est transtypé vers une
classe qui n'existe plus ou pas au moment de l'exécution.
M. BOUAABID Mourad 8
LANGAGE JAVA
La classe ObjectInputStream possède de la même façon que la classe ObjectOutputStream des
méthodes pour lire des données de type primitives : readInt(), readDouble(), readFloat(), ...
Lors de la désérialisation, le constructeur de l'objet n'est jamais utilisé.
6 Le mot clé transient
Le contenu des attributs est visible dans le flux dans lequel est sérialisé l'objet. Il est ainsi possible
pour toute personne ayant accès au flux de voir le contenu de chaque attribut même si ceux si sont
private. Ceci peut poser des problèmes de sécurité surtout si les données sont sensibles.
Java introduit le mot clé transient qui précise que l'attribut qu'il qualifie ne doit pas être inclus
dans un processus de sérialisation et donc de désérialisation.
private transient String codeSecret;
Lors de la désérialisation, les champs transient sont initialisés avec la valeur null. Ceci peut poser
des problèmes à l'objet qui doit gérer cet état pour éviter d'avoir des exceptions de type
NullPointerException.
7 La sérialisation personnalisée
Il est possible de personnaliser la sérialisation d'un objet. Dans ce cas, la classe doit implémenter
l'interface Externalizable qui hérite de l'interface Serializable.
Cette interface définit deux méthode : readExternal() et writeExternal().
Par défaut, la sérialisation d'un objet qui implémente cette interface ne prend en compte aucun
attribut de l'objet.
Remarque : le mot clé transient est donc inutile avec une classe qui implémente l'interface
Externalisable
M. BOUAABID Mourad 9