Chapitre 8: Fichiers

1
 Introduction
❑En java, les fichiers sont représentés par des objets
particuliers appelés en anglais (Stream). Ce mot signifie
flot en français.
❑Les streams sont représentés dans des classes définies
dans le package [Link].
❑Il existe de nombreuses sortes de streams, qui peuvent
être classés selon plusieurs critères:
❖Streams d’entrée (lecture) et streams de sortie (écriture)
❖Streams de caractères (texte) et streams de données
binaires
❖Streams avec et sans tampon de données
…
2
 Introduction
Un flux

❑Un tuyau de transport séquentiel de données

❑Unidirectionnel
❑Il existe un flux par type de données à transporter
(Image, Texte ou Son)
Exemple:
Flux d’entrée Programme JAVA
-------------
Informations
Informations -------------
Informations -------------
Flux de sortie
3
 Cycle d’utilisation d’un flux

❑ Le cycle d’utilisation d’un flux de données

(lecture ou écriture) est le suivant:
1. Ouverture du flux
2. Traitement(lecture des données ou écriture des
données)
3. Fermeture du flux

4
 Classe [Link]
❑ File : classe modélisant un fichier (ou
un répertoire) de manière indépendante du
système. Cette classe fournit des méthodes
pour lister les répertoires, interroger des
attributs de fichiers (droits en lecture, en
écriture), renommer ou détruire des fichiers.
❑ La déclaration et la création s’effectue de la
façon suivante :
File fich = new File(‘’Nom_fich.extension’’);
File rep = new File(‘’Nom_répertoire’’);
5
 Classe [Link]
Parmi les méthodes de [Link], on trouve:
❑ String getName(): retourne le nom du fichier
❑ String getParent(): retourne le nom du répertoire père
❑ boolean exists(): teste l’existence du fichier
❑ boolean canWrite(): teste la possibilité d’écriture
❑ boolean canRead(): teste la possibilité de lecture
❑ long length(): retourne la taille du fichier
❑ boolean mkdir() : créer un répertoire
❑ boolean CreateNewFile(): créer un fichier
❑ …etc
6
 3. Classe [Link]
Exemple1:
import [Link]; public
class Main {
public static void main(String[] args) {
File f = new File("[Link]");
[Link]("Chemin absolu du fichier : " +
[Link]());
[Link]("Nom du fichier : " + [Link]());
[Link]("Est-ce qu'il existe ? " + [Link]());
[Link]("Est-ce un répertoire ? " + [Link]());
[Link]("Est-ce un fichier ? " + [Link]());
}

7
 3. Classe [Link]
Exemple1:

L’exécution du programme, nous affiche :

Chemin absolu du fichier :
C:\Users\info\Documents\NetBeansProjects\ppp\[Link]
Nom du fichier : [Link]
Est-ce qu'il existe ? true
Est-ce un répertoire ? false
Est-ce un fichier ? true

8
 Streams de données binaires
En java, les streams de données binaires dérivent des
deux classes:
❖ [Link] pour les entrées (lecture)
❖ [Link] pour les sorties (écriture)
a. Ecriture dans un fichier de données binaires:
Les streams d’écriture pour les données binaires sont
des sous classes de la classe [Link] :
❖DataOutputStream: Ecriture séquentielle dans un
fichier binaire
❖BufferedOutputStream: Ecriture des données à l’aide
d’un tampon
❖…
9
 Streams de données binaires
❑La classe DataOutpuStream admet le constructeur :
DataOutpuStream(FileOutputStream out) : créer un
stream d’écriture sur out
❑Quelques méthodes de la classe DataOutputStream :

Méthode Description
writeUTF() Ecriture d’une chaîne de caractères
writeInt() Ecriture d’un entier
writeFloat() Ecriture d’un réel de type Float
close() Fermeture du stream
…etc
10
 Streams de données binaires
Exemple2:
import [Link].*;
class EcritureFichierBinaire{
public static void main(String[] arg) throws IOException
File fich = new File("[Link]"); DataOutputStream ecrivain;
ecrivain = new DataOutputStream (new
FileOutputStream(fich));
[Link]("Bonjour");
[Link](5);
[Link]('a');
[Link](false);
[Link]([Link]());
[Link]();
}} 11
 Streams de données binaires
b. Lecture dans un fichier de données binaires :
❑ Les streams d’entrée pour les données binaires sont
des sous classes de la classe [Link] :
❖DataInputStream : Lecture séquentielle dans un
fichier binaire
❖BufferedInputStream : Lecture des données à l’aide
d’un tampon
❖…
❑ La classe DataInputStream admet le constructeur :
DataInputStream(FileInputStream in) : créer un
stream d’entrée.
12
 Streams de données binaires
❑ Quelques méthodes de la classe DataInputStream :

Méthode Description
readChar() Lire un caractère
readInt() Lire un entier
readFloat() Lire un réel de type
close() Float Fermer le stream d’entrée
… etc

13
 Streams de données binaires
Exemple3 :
import [Link].*;
class LireFichierBinaire {
public static void main(String[] arg) throws IOException {
File fich = new File(" test,txt");
DataInputStream lecture;
lecture = new DataInputStream (new FileInputStream(fich));
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
[Link]();
}
}

14
 Streams de caractères
❑Les streams caractères sont conçus pour la lecture et
l’écriture de texte. Ils dérivent des deux classes
abstraites : [Link] pour les entrées et
[Link] pour les sorties.
a. Ecriture dans un fichier texte:
❑Pour écrire dans un fichier texte, il faut utiliser les
streams d’écriture qui sont des sous-classes de la
classe [Link], qui contient les sous classes
suivantes:
❖FileWriter : sous-classe particulière de
OutputStreamWriter utilisant la taille de tampon
par défaut.
15
 Streams de caractères

❖OutputStreamWriter : Convertir un stream de

données binaires en stream de caractères.
❖BufferedWriter : Ecriture de caractères à l’aide
d’un tampon (à la fin de chaque ligne écrite, on
utilise la méthode newLigne())
❖PrintWriter : Ecrire des caractères formatés (la
méthode println() permet d’écrire sur le fichier texte).

16
 5. Streams de caractères
Exemple4:
import [Link].*;
class EcrireFichierTexte{
public static void main(String[] arg) throws IOException{
File fich = new File(" [Link]");
PrintWriter ecrivain; int i=10;
ecrivain = new PrintWriter (new
FileOutputStream(fich)); [Link]("Bonjour");
[Link](" Comment cela va-t-il?");
[Link](" On peut mettre des entiers");
[Link](i);
[Link]();
}
} 17
 5. Streams de caractères
Exemple5:

import [Link].*;
class EcrireFichierTexte{
public static void main(String[] arg) throws IOException {
File fich = new File(" [Link]");
FileWriter ecrivain = new FileWriter (fich);
[Link]("Bonjour");
[Link]();
}
}

18
 5. Streams de caractères
b. Lecture dans un fichier texte:
❑ Pour lire dans un fichier texte, on doit utiliser des sous-
classes de la classe [Link]. Deux méthodes de cette
classe sont abstraites:
❖ read(char[]cbuf,int off,int len): permet de lire len
caractères et de les placer dans le tableau cbuf, à partir de
l’indice off.
❖ close(): ferme le stream.
❑ Toutes les classes dérivées de Reader redéfinissent donc
obligatoirement ces deux méthodes.
❖ FileReader: sous-classe particulière de
InputStreamReader utilisant une taille de tampon par
défaut.
❖ BufferedReader: lecture de caractères à l’aide d’un tampon.19
 5. Streams de caractères

Exemple 6:
Il s’agit de lire un fichier texte ligne par ligne et
de reproduire ce qui est lu directement à l’écran.

} 19
 Streams de caractères
import [Link].*;
class LireLigne {
public static void main(String[] args) throws IOException {
BufferedReader lectureAvecBuffer = null;
String ligne;
try {
lectureAvecBuffer = new BufferedReader(new
FileReader(args[0]));
} catch (FileNotFoundException exc) {
[Link]("Erreur d’ouverture du fichier : " +
[Link]());
}
while ((ligne = [Link]()) != null) {
[Link](ligne);
}
[Link]();
} 19
}}
 5. Streams de caractères

Exemple 7:
Il s’agit de lire des entiers dans un fichier
ne contenant que des entiers et d’en faire
la somme.

22
 Streams de caractères
import [Link].*;
class LireEntiers {
public static void main(String[] args) throws IOException {
if ([Link] == 0) {
[Link]("Veuillez fournir le nom du fichier en
argument.");
}
FileReader fichier = new FileReader(args[0]);
int somme = 0;
StreamTokenizer entree = new StreamTokenizer(fichier);
while ([Link]() == StreamTokenizer.TT_NUMBER) {
somme += (int) [Link];
}
[Link]("La somme est : " + somme);
[Link]();
}
19
}
 5. Streams de caractères
import [Link].*;
Exemple 8:
class CopieTxt
Il s’agit de lire un fichier {
texte de nom public static void main(String[] arg) throws IOException
{
« [Link] » et copie FileReader entree=new FileReader("[Link]");
ce fichier dans un autre FileWriter sortie=new FileWriter(" [Link]");
fichier de nom int c;

« [Link] ». Nous allons while((c=[Link]())!=-1)

utiliser les streams [Link](c);
FileReader et FileWriter. [Link]();
[Link]();
}
}

24
 Streams de caractères
import [Link].*;
class CopieTxt {
public static void main(String[] args) throws IOException {
FileReader entree = new FileReader("[Link]");
FileWriter sortie = new FileWriter("[Link]");
int c;
while ((c = [Link]()) != -1) {
[Link](c);
}
[Link]();
[Link]();
}
}

19
 Résumé
Fichier

Stream Stream de
binaire caractères

[Link] [Link] [Link] [Link]

DataOutputStream FileWriter
DataInputStream OutputStreamWrit FileReader
BufferedOutputStream BufferedInputStream BufferedReader
…. er BufferedWriter
…. PrintWriter ….
….

26
 Stream de données binaires
DataInputStream

BufferedInputStream

DataOutputStream

BufferedOutputStream

27
 Stream de caractères
FileReader

BufferedReader

FileWriter

BufferedWriter

PrintWriter

OutputStreamWriter
28