ROYAUME DU MAROC

Université Cadi Ayyad

Ecole Nationale des Sciences Appliqués
Département Génie Informatique, Réseaux & Télécoms
Safi
____________

JAVA II

2ème Année du Cycle Ingénieur :

- Option Génie Informatique (GI)
- Option Ingénieurie des Données & Intelligence Artificielle (IDIA)
[Link]@[Link]
oujaouram@[Link] Mustapha OUJAOURA
Chap 03: Les flux
• Introduction
• Package [Link]
• Les flux binaires
• Les flux d'entrée
• Les flux de sortie
• Les flux de caractères
• Les flux d'entrée
• Les flux de sortie
• Récapitulation sur les flux
• La classe File
 Introduction
3

¨ Une entrée/sortie en Java consiste à échanger des données

entre le programme et une autre source qui peut être:
¤ la mémoire,
¤ un fichier,
¤ ou le programme lui-même..... .
¨ Pour réaliser cela, Java emploie ce qu'on appelle
un stream (qui signifie flux ) entre la source et la destination
des données.
¨ Toute opération d'entrée/sortie en Java suit le schéma suivant :
¤ Ouverture d'un flux;
¤ Lecture ou écriture des données;
¤ Fermeture du flux.
¨ Le package [Link] fournit toutes les classes nécessaires à
la création, lecture, écriture et traitement des flux.
 Le package [Link]
4

¨ Le package [Link] comporte plusieurs sortes de flux qui peuvent être classés
suivant plusieurs critères:
¤ les flux d'entrée et les flux de sortie
¤ les flux de caractères et les flux binaires (dû au fait que java utilise l'unicode donc
les caractères sont codés sur 2 octets et non sur un seul )
¤ les flux de communication et les flux de traitement
¤ les flux avec ou sans tampon
¤ ...
¨ On commence d'abord par :
¤ les flux binaires
n les flux de communication
n les flux de traitement
¤ les flux de caractères
n les flux de communication
n les flux de traitement.
 Les flux binaires
5

¨ Les flux binaires servent à manipuler des octets, c'est-à-dire qu'il y a

échange d'octets entre le programme et une autre entité extérieur à ce
dernier.
¨ Ce genre de flux peut servir à charger en mémoire des images ou bien de
les enregistrer sur le disque, ils sont aussi utilisés pour enregistrer des objets
(procédé nommé sérialisation ) ou les charger (désérialisation ).
¨ Les flux binaires dérivent de deux classes:
¤ InputStream pour les flux d'entrée et
¤ OutputStream pour les flux de sortie.
¨ Ces deux classes sont abstraites. On ne les utilisera donc pas directement
pour obtenir un flux mais on utilisera une de leurs nombreuses classes filles.
¨ On notera la présence d'un certains nombres de méthodes, à savoir les
différentes méthodes write pour OutputStream et les différentes
méthodes read pour InputStream.
¨ Il est grand temps maintenant de détailler les différentes classes filles et leurs
rôles. Nous aborderons tout d'abord les flux d'entrée puis ceux de sortie.
 Les flux d'entrée
6

¨ Ces flux sont des sous-classes de InputStream et peuvent

être classés en deux catégories:
¤ Les flux de communication, servant essentiellement à créer une
liaison entre le programme et une autre entité.
¤ Les flux de traitement qui, comme leur nom l'indique, servent
plutôt à traiter les données échangées.
 Les flux de communication
7

¨ Ils sont composés des classes suivantes:

¤ FileInputStream:
n permet de créer un flux avec un fichier présent dans le système de fichiers.
n Cette classe possède un constructeur prenant en paramètre un objet de type File et un
autre prenant un String comme paramètre, qui représente le chemin vers le fichier.
¤ ByteArrayInputStream:
n permet de lire des données binaires à partir d'un tableau d'octets. La source de ce flux
est donc le programme lui-même.
¤ PipedInputStream:
n permet de créer une sorte de tube d'entrée (pipe) dans lequel circuleront des octets.
n Cette classe possède un constructeur ayant pour paramètre un objet de
type PipedOutputStream.
n On peut ainsi connecter les deux tubes, c'est-à-dire que ce qui est écrit dans une
extrémité peut être lu depuis l'autre.
n Dans la pratique, on les utilise pour faire communiquer deux threads. La présence d'un
buffer permet de découpler les performances des opérations de lecture et d'écriture et
cela sans limite.
 Les flux de communication: Lecture
(Exemple)
8
//code permettant de charger le contenu binaire d'un fichier et de l'afficher sur la sortie standard.
import [Link].*;
public class FileInputStreamExemple {
public static void main(String[] args) {
FileInputStream fis;
int byteLu;
try {
// creation d'un flux d'entrée ayant pour source un fichier nommé source
// cette instanciation peut lever une exception de type FileNotFound
fis = new FileInputStream("ressources/fichiers/[Link]");
// la methode read() renvoie un int representant l'octet lu,
// la valeur (-1) represente la fin du fichier.
// read peut lever une exception du type IOException
try {
while ((byteLu = [Link]()) != -1) {
[Link](byteLu);
}
}
// Ne pas oublier de fermer le flux afin de liberer les ressources
// qu'il utilise
finally {
[Link]();
}
} catch (FileNotFoundException ef) {
[Link]("fichier introuvable");
} catch (IOException e) {
[Link](e + "erreur lors de la lecture du fichier");
}
}
}
// On remarque que la sortie de ce programme sont des chiffres compris entre 0 et 255
 Les flux de communication: Lecture
(Exemple)
9
// code qui charge le contenu binaire d'un tableau de bytes et de l'afficher sur la sortie standard.
import [Link].*;
public class ByteArrayInputStreamExemple {
public static void main(String[] args) {
ByteArrayInputStream bis;
int byteLu;
byte[] buffer = new byte[10];
// remplissage de buffer
for (byte i = 0; i < 10; i++) {
buffer[i] = i;
}
// creation d'un flux d'entrée ayant pour source un tableau de bytes, ici buffer
bis = new ByteArrayInputStream(buffer);
// lecture du flux.
// A noter que les valeurs retournées sont de type int et non de type byte
while ((byteLu = [Link]()) != -1) {
[Link](byteLu);
}
}
}
// On remarque, d'après l'affichage obtenu, que les valeurs sont lues séquentiellement en partant de
l'élément d'indice 0 .
 Les flux de traitement
10
¨ Ils viennent se greffer sur les flux de communication afin de réaliser un traitement sur les
données lues.
¨ Ils se composent des classes BufferedInputStream, DataInputStream, PushBackInputStream qui
étendent la classe FilterInputStream, mais aussi de SequenceInputStream et ObjectInputStream.
¤ DataInputStream:
n Sert à lire des données représentant des types primitifs de Java (int, boolean, double, byte, ...) qui ont été
préalablement écrits par un DataOutputStream.
n Ainsi cette classe possède des méthodes comme : readInt() , readBoolean() , ...
¤ SequenceInputStream:
n Permet de concaténer deux ou plusieurs InputStream.
n La lecture se fait séquentiellement en commençant par le premier et en passant au suivant dès qu'on a atteint la fin du
flux courant, tout en appelant sa méthode close() .
¤ ObjectInputStream:
n Permet de «désérialiser» un objet, c'est-à-dire de restaurer un objet préalablement sauvegardé à l'aide d'un
ObjectOutputStream.
¤ BufferedInputStream:
n Cette classe permet la lecture de données à l'aide d'un tampon.
n Lorsqu'elle est instanciée, un tableau d'octets est créé afin de servir de tampon.
n Ce tableau est redimensionné automatiquement à chaque lecture pour contenir les données provenant du flux
d'entrée.
n Pour comprendre le grand intérêt de cette classe, exécutez les deux codes suivants et remarquez la différence au
niveau des performances (Employez un fichier source de quelques Mo ).
 Les flux de traitement : Lecture
(Exemple)
11

import [Link].*;
public class TestFileInputStream {
public static void main(String[] args) {
FileInputStream fis;
int byteLu;
try {
// creation d'un flux d'entrée ayant pour source un fichier nommé source
// cette instanciation peut lever une exception de type FileNotFound
fis = new FileInputStream("source");
// lecture des données
try {
long startChrono = [Link]();
[Link]("debut lecture");
while ((byteLu = [Link]()) != -1) ;
[Link]("fin lecture");
[Link]("durée=" + ([Link]() - startChrono));
} finally {
// fermeture du flux
[Link]();
}
} catch (FileNotFoundException ef) {
[Link]("fichier introuvable");
} catch (IOException e) {
[Link](e);
}
}
}
 Les flux de traitement : Lecture
(Exemple)
12
import [Link].*;
public class TestBufferedInputStream {
public static void main(String[] args) {
BufferedInputStream bis;
int byteLu;
Byte[] buffer;
try {
// creation d'un BufferedInputStream sur un InputStream ayant pour
// source un fichier nommé source,
bis = new BufferedInputStream(new FileInputStream("source"));
// la methode available permet de connaitre le nombre de bytes qui
// pourront étre lus d'une manière non bloquante.
[Link]([Link]());
// lecture des données
[Link]("debut lecture");
try {
long startChrono = [Link]();
while ((byteLu = [Link]()) != -1) ;
[Link]("fin lecture");
[Link]("durée=" + ([Link]() - startChrono));
} finally {
// ne pas oublier de refermer le flux
[Link]();
}
} catch (FileNotFoundException ef) {
[Link]("fichier introuvable");
} catch (IOException e) {
[Link](e);
}
}
}
 Les flux de sortie
13

¨ Pour chaque flux d'entrée vu précédemment, correspond

un flux de sortie.
¨ Les classes de flux de sortie font le travail inverse de celles
flux d'entrée abordées précédemment.
¨ Les flux de sortie sont aussi classés en
¤ flux de communication et
¤ flux de traitement.
 Les flux de communication
14

¨ Par symétrie , Ils sont composés des classes suivantes:

¤ FileOutputStream:
n Permet l'écriture séquentielle de données dans un fichier.
¤ ByteArrayOutputStream:
n Permet d'écrire les données dans un tampon dont la taille s'adapte
en fonction du besoin.
n On peut récupérer les données écrites avec la méthode
toByteArray() ou bien toString().
n A noter qu'un appel à la méthode close() aussi bien pour cette
classe que pour ByteArrayInputStream est sans effet.
¤ PipedOutputStream:
n Permet la création d'un tube (pipe)
 Les flux de communication: Ecriture
(Exemple)
15
import [Link].*;
public class FileOutputStreamExemple {
public static void main(String[] args) {
FileInputStream fis;
FileOutputStream fos;
int byteLu;
try {
// creation d'un flux d'entrée ayant pour source un fichier source,
// cette instanciation peut lever une exception de type FileNotFound
fis = new FileInputStream("source");
try {
// création d'un flux de sorite vers un fichier nommé dist,
// s'il n'existe pas il sera crée sinon il sera écrasé
fos = new FileOutputStream("dist");
try {
// on lit octet par octet depuis le fichier source
// et on écrit dans le fichier dist
while ((byteLu = [Link]()) != -1) {
[Link](byteLu);
}
} finally {
[Link](); // on ferme fos
}
} finally {
[Link](); // on libère les ressources en fermant fis
}
} catch (FileNotFoundException ef) {
[Link]("fichier introuvable");
} catch (IOException e) {
[Link](e);
}
}
}
 Les flux de communication: Ecriture
(Exemple)
16

import [Link].*;
public class ByteArrayOutputStreamExemple {
public static void main(String[] args) {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
int byteLu;
byte[] tab = new byte[10];
// ecriture dans le tampon
for (byte i = 0; i < 10; i++) {
[Link](i);
}
// récuperation des données contenues dans le tampon
tab = [Link]();
// affichage des données
for (int j = 0; j < 10; j++) {
[Link](tab[j]);
}
}
}
 Les flux de communication: Ecriture
(Exemple)
17

import [Link].*;
class ThreadEcriture implements Runnable{
private PipedOutputStream pos;
public ThreadEcriture(PipedOutputStream pos){
[Link]=pos;
}
public void run(){
try{
for(int i=0;i<50;i++){
[Link](i);
[Link]("threadEcriture: j'ai ecrit "+i);
[Link](500);
}
}
catch(Exception e){
[Link](e);
}finally{
try{
[Link]();
}catch(IOException eio){
[Link](eio);
}
}
}
}
class ThreadLecture implements Runnable{
private PipedInputStream pis;
int i;
public ThreadLecture(PipedInputStream pis){
[Link]=pis;
}
 Les flux de communication: Ecriture
(Exemple)
18
public void run(){
try{
while (( i=[Link]())!=-1) {
[Link]("threadLecture : j'ai lu "+i);
}
}catch(IOException e){
[Link](e);
}finally{
try{
[Link]();
}catch(IOException eio){
[Link](eio);
}
}
}
}
public class PipedOutputStreamExemple {
public static void main(String[] args){
try{
//création des deux pipes et leur connexion
PipedOutputStream pos = new PipedOutputStream();
PipedInputStream pis = new PipedInputStream(pos);
ThreadEcriture tecr = new ThreadEcriture(pos);
ThreadLecture tlec = new ThreadLecture(pis);
Thread premier = new Thread(tecr);
Thread second = new Thread(tlec);
[Link]();
[Link]();
}
catch(IOException e){
[Link](e);
}
}
 Les flux de traitement
19

¨ Ils se composent des classes :

¤ BufferedOutputStream:
n Permet d'écrire dans un tampon puis d'écrire le tampon en entier sur
le fichier au lieu d'écrire octet par octet sur le fichier.
¤ DataOutputStream:
n Cette classe permet l'écriture de données sous format Java et assure
une portabilité inter-applications et inter-systèmes.
¤ ObjectOutputStream:
n Permet de sauvegarder l'état d'un objet dans un fichier ou autre.
n Pour cela, l'objet doit implémenter l'interface serializable.
n Seuls les membres non-transcients et non statiques seront
sauvegardés.
 Les flux de traitement : Ecriture
(Exemple)
20

import [Link].*;
public class BufferedOutputStreamExemple {
public static void main(String[] args) {
int i;
try {
// création des flux
BufferedInputStream in = new BufferedInputStream(new FileInputStream("source"));
try {
BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("dist"));
// copie du fichier
try {
while ((i = [Link]()) != -1) {
[Link](i);
}
// vider le contenu du tampon
[Link]();
} finally {
// fermeture de out
[Link]();
}
} finally {
// fermeture de in
[Link]();
}
} catch (IOException e) {
[Link](e);
}
}
}
 Les flux de traitement : Ecriture
(Exemple)
21

import [Link].*;
public class DataOutputStreamExemple {
public static void main(String[] args) {
try {
// creation du flux
DataOutputStream out = new DataOutputStream(new FileOutputStream("sortie"));
// données à ecrire
boolean test = true;
int i = 100;
try {
// ecriture des données
[Link](test);
[Link](i);
// vider le buffer
[Link]();
} finally {
// fermer le flux
[Link]();
}
} catch (IOException e) {
[Link](e);
}
}
}
 Les flux de traitement : Ecriture
(Exemple)
22

import [Link].*;
public class DataInputStreamExemple {
public static void main(String[] args) {
try {
// creation du flux
DataInputStream in = new DataInputStream(new FileInputStream("sortie"));
// données à lire
boolean test;
int i;
try {
// lecture des données
test = [Link]();
i = [Link]();
} finally {
// fermer le flux
[Link]();
}
// affichage des données
[Link](test);
[Link](i);
} catch (IOException e) {
[Link](e);
}
}
}
 Les flux de traitement : Ecriture
(Exemple)
23
import [Link].*;
class Personne implements Serializable{
private static final long serialVersionUID = 1L;
private int age;
private String nom;
public Personne(){
[Link]=22; [Link]="toto";
}
public String toString(){
return "nom: "+nom+"\nage: "+age;
}
}
public class ObjectOutputStreamExemple {
public static void main(String[] args) {
try {
Personne per = new Personne();
Personne personne;
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("fichierObjet"));
try {
[Link](per); // ecriture de l'objet
[Link]();
} finally {
[Link]();
}
ObjectInputStream in = new ObjectInputStream(new FileInputStream("fichierObjet"));
try {
personne = (Personne) [Link](); // lecture de l'objet
[Link](personne); // affichage
} finally {
[Link](); // fermer le flux
}
} catch (Exception e) {
[Link](e);
 Les flux de caractères
24
¨ Les flux de caractères servent à manipuler des caractères, c'est-à-dire qu'il y a
échange de caractères entre le programme et une autre entité extérieur à ce dernier.
¨ Java, contrairement à beaucoup d'autres langages, utilise Unicode. Ainsi, les
caractères sont codés sur 16 bits et non sur 8. C’est pour cela que java a introduit ce
genre de flux.
¨ Ces flux servent donc à gérer les jeux de caractères (conversion possible d'un jeu à
l'autre). .
¨ Les flux de caractères dérivent de deux classes :
¤ Reader pour les flux d'entrée et
¤ Writer pour les flux de sortie.
¨ Ces deux classes sont abstraites. On ne les utilisera donc pas directement pour
obtenir un flux mais on utilisera une de leurs nombreuses classes filles.
¨ On notera la présence d'un certains nombres de méthodes, à savoir les différentes
méthodes write pour Writer et les différentes méthodes read pour Reader.
¨ Il est grand temps maintenant de détailler les différentes classes filles et leurs rôles.
Nous aborderons tout d'abord les flux d'entrée puis ceux de sortie.
 Les flux d'entrée
25

¨ Ces flux sont des sous-classes de la classe

abstraite Reader et peuvent être classés en deux
catégories:
¤ Les flux de communication, servant essentiellement à créer une
liaison entre le programme et une autre entité.
¤ Les flux de traitement qui, comme leur nom l'indique, servent
plutôt à traiter les données échangées.
 Les flux de communication
26

¨ Ils sont composés des classes suivantes:

¤ CharArrayReader:
n c'est l'équivalent de ByteArrayInputStream pour les caractères. Il utilise aussi
un tampon indexé pour la lecture des caractères.
¤ StringReader:
n permet la lecture de caractères à partir d'une chaine. La chaine en
question est alors la source du flux .
¤ PipedReader:
n a un comportement très similaire à PipedInputStream : elle se connecte à
un PipedWriter afin de créer un tube pour l'échange de caractères.
¤ FileReader:
n C'est sûrement la classe la plus importante car c'est certainement la plus
utilisée.
n Elle étend InputStreamReader et utilise le tampon et l'encodage par défaut.
n Elle convient donc dans la plupart des cas.
n Si on a besoin d'un autre encodage on doit étendre InputStreamReader.
 Les flux de communication: Lecture
(Exemple)
27
import [Link].*;
public class CharArrayReaderExemple {
public static void main(String[] args) {
try {
char[ ] tab = { 'a', 'b', 'c', 'd', 'e' };
CharArrayReader car = new CharArrayReader(tab); // creation du flux
// lecture et affichage des données
for (int i = 0; i < 5; i++) {
[Link]((char) [Link]());
}
} catch (IOException e) {
[Link](e);
}
}
}

import [Link].*;
public class StringReaderExemple {
public static void main(String[] args) {
try {
int i;
String chaine = "toto va à l'école";
StringReader sr = new StringReader(chaine); // creation du flux
// lecture et affichage des données
while ((i = [Link]()) != -1) {
[Link]((char) i);
}
} catch (IOException e) {
[Link](e);
}
}
}
 Les flux de communication: Lecture
(Exemple)
28

import [Link].*;
public class FileReaderExemple {
public static void main(String[] args) {
try {
int i;
// creation du flux
FileReader fr = new FileReader("source");
try {
// lecture et affichage des données
while ((i = [Link]()) != -1) {
[Link]((char) i);
}
} finally {
[Link]();
}
} catch (IOException e) {
[Link](e);
}
}
}
 Les flux de traitement
29

¨ Ils permettent de réaliser un traitement sur les données lues par les flux de
communication
¨ Ils se composent des classes :
¤ InputStreamReader:
n Cette classe permet de transformer un flux de données binaires en un flux de
caractères.
n Elle est très utile lorsque le tampon ou l'encodage par défaut de FileReader ne
conviennent pas.
n Elle possède un constructeur qui prend en paramètres un flux d'entrée de données
binaires et un Charset (objet servant à définir l'encodage à utiliser).
n La méthode read() lit le nombre nécessaire d'octets constituant un caractère.
¤ BufferedReader:
n Cette classe permet l'emploi d'un tampon (dont on peut spécifier la taille) lors de la
lecture d'un flux de caractères.
n Elle est très utile pour améliorer la performance de l'opération de lecture.
n Son emploi est analogue à celui de BufferedInputStream.
¤ LineNumberReader:
n sous-classe de BufferedReader, elle en hérite donc l'utilisation d'un tampon et permet en
plus de lire ligne par ligne (tout en les comptant) grâce à la méthode readLine().
 Les flux de traitement : Lecture
(Exemple)
30

import [Link].*;
public class LineNumberReaderExemple {
public static void main(String[] args) {
try {
String ligneLue;
// creation du flux
LineNumberReader lnr = new LineNumberReader(new FileReader("source"));
try {
// lecture et affichage des données
while ((ligneLue = [Link]()) != null) {
System. [Link](ligneLue);
}
} finally {
// libération des ressources
[Link]();
}
} catch (IOException e) {
System. [Link](e);
}
}
}
 Les flux de sortie
31

¨ A chaque flux d'entrée vu précédemment, correspond un

flux de sortie sauf pour la classe LineNumberReader.
¨ Ils étendent tous la classe Writer et redéfinissent, en plus
de la méthode write(), la méthode flush() qui vide le
tampon en forçant l'écriture effective des caractères
présents dans ce dernier.
¨ Les classes de flux de sortie font le travail inverse de celles
flux d'entrée abordées précédemment.
¨ Les flux de sortie sont aussi classés en
¤ flux de communication et
¤ flux de traitement.
 Les flux de communication
32

¨ Par symétrie , Ils sont composés des classes suivantes:

¤ CharArrayWriter:
n permet l'écriture de caractères dans un tampon dont la taille varie afin de
contenir les données.
n A noter que la méthode close() n'a aucun effet sur une instance de cette classe
et que l'appel d'autres méthodes après close() ne lèvent pas d'IOException.
¤ StringWriter:
n permet l'écriture de caractères dans un StringBuffer.
n Son contenu peut être obtenu sous forme de String grâce à la méthode
toString().
¤ PipedWriter:
n permet de créer un tube où circuleront les caractères en se connectant à un
objet de type PipedReader.
¤ FileWriter:
n Elle convient pour la plupart des cas d'écriture dans un fichier, son
fonctionnement est l'opposé de FileReader.
n Cependant elle utilise aussi le tampon et l'encodage par défaut.
 Les flux de traitement
33

¨ Ils se composent des classes :

¤ OutputStreamWriter:
n convertit un flux de données binaires en un flux de caractères.
¤ PrintWriter:
n permet d'écrire des caractères formatés, très utile pour l'affichage
en mode texte.
¤ BufferedWriter:
n permet l'utilisation d'un tampon et donc d'écrire les caractères par
bloc.
 Les flux de traitement : Ecriture
(Exemple)
34

import [Link].*;
public class BufferedWriterExemple1 {
public static void main(String[] args) {
try {
String ligne;
// creation des flux
BufferedReader in = new BufferedReader(new FileReader("source"));
// lecture et copie des données
try {
BufferedWriter out = new BufferedWriter(new FileWriter("dist"));
try {
while ((ligne = [Link]()) != null) {
[Link](ligne);
// insérer un saut de ligne d'une manière portable
[Link]();
}
[Link](); // vider le buffer
} finally {
// fermeture de out
[Link]();
}
} finally {
[Link]();
}
} catch (IOException e) {
[Link](e);
}
}
}
 Récapitulation sur les flux
35

¨ Le tableau récapitule des différentes classes, vu jusqu'à présent, en adoptant

une autre façon de les classer à savoir la destination vu que tous les flux
établissent une liaison entre le programme et une destination.

Destination flux binaires flux de caractères

ByteArrayInputStream CharArrayReader

ByteArrayOutputStream CharArrayWriter
La mémoire
StringBufferInputStream StringReader

StringWriter

FileInputStream FileReader
Un fichier
FileOutputStream FileWriter

Un chaînage de flux PipedInputStream PipedReader

 Gestion des répertoires et des
fichiers : Classe File
36

¨ Les fichiers et les répertoires sont encapsulés dans la

classe File du package [Link].
¨ Il n'existe pas de classe pour traiter les répertoires car ils
sont considérés comme des fichiers.
¨ Une instance de la classe File est une représentation
logique d'un fichier ou d'un répertoire qui peut ne pas
exister physiquement sur le disque.
¨ Si le fichier ou le répertoire existe, de nombreuses
méthodes de la classe File permettent d'obtenir des
informations sur le fichier. Sinon plusieurs méthodes
permettent de créer des fichiers ou des répertoires.
¨ Voici une liste des principales méthodes :
 Gestion des répertoires et des
fichiers : Classe File
37

Méthode Rôle
boolean canRead() Indiquer si le fichier peut être lu
boolean canWrite() Indiquer si le fichier peut être modifié
boolean createNewFile() Créer un nouveau fichier vide
Créer un nouveau fichier dans le répertoire par défaut des
File createTempFile(String, String) fichiers temporaires. Les deux arguments sont le nom et le
suffixe du fichier
File createTempFile(String, String, Créer un nouveau fichier temporaire. Les trois arguments
File) sont le nom, le suffixe du fichier et le répertoire
Détruire le fichier ou le répertoire. Le booléen indique le
boolean delete()
succès de l'opération
deleteOnExit() Demander la suppression du fichier à l'arrêt de la JVM
boolean exists() Indique si le fichier existe physiquement
 Gestion des répertoires et des
fichiers : Classe File
38

Méthode Rôle
String getAbsolutePath() Renvoyer le chemin absolu du fichier
String getPath Renvoyer le chemin du fichier
boolean isAbsolute() Indiquer si le chemin est absolu
boolean isDirectory() Indiquer si le fichier est un répertoire
boolean isFile() Indiquer si l'objet représente un fichier
long length() Renvoyer la longueur du fichier
String[] list() Renvoyer la liste des fichiers et répertoires contenus dans le répertoire
boolean mkdir() Créer le répertoire
Créer le répertoire avec création des répertoires manquants dans
boolean mkdirs()
l'arborescence du chemin
boolean renameTo() Renommer le fichier
 Gestion des répertoires et des
fichiers : Classe File
39

¨ Depuis la version 1.2 du J.D.K., de nombreuses

fonctionnalités ont été ajoutées à cette classe :
¤ la création de fichiers temporaires (createNewFile,
createTempFile, deleteOnExit)
¤ la gestion des attributs "caché" et "lecture seule" (isHidden,
isReadOnly)
¤ des méthodes qui renvoient des objets de type File au lieu du
type String ( getParentFile, getAbsoluteFile, getCanonicalFile,
listFiles)
¤ une méthode qui renvoie le fichier sous forme d'URL (toURL)
 Gestion des répertoires et des
fichiers : Classe File (Exemple)
40
import [Link].*;
public class GestionFileExemple {
protected String nomFichier;
protected File fichier;
public GestionFileExemple(String nomFichier) {
[Link] = nomFichier;
fichier = new File(nomFichier);
traitement();
}
public static void main(String args[]) {
new GestionFileExemple("ressources/fichiers");
}
private void traitement() {
if (![Link]()) {
[Link]("le fichier " + nomFichier + "n'existe pas");
[Link](1);
}
if (![Link]()) {
[Link](" Nom du fichier : " + [Link]());
[Link](" Chemin du fichier : " + [Link]());
[Link](" Chemin absolu : " + [Link]());
[Link](" Droit de lecture : " + [Link]());
[Link](" Droit d'ecriture : " + [Link]());
}
if ([Link]()) {
[Link](" Nom du repertoire : " + [Link]());
[Link](" Chemin du repertoire : " + [Link]());
[Link](" Chemin absolu : " + [Link]());
[Link](" Droit de lecture : " + [Link]());
[Link](" Droit d'ecriture : " + [Link]());
[Link](" contenu du repertoire ");
 Gestion des répertoires et des
fichiers : Classe File (Exemple)
41
File fichiers[] = [Link]();
for (int i = 0; i < [Link]; i++) {
if (fichiers[i].isDirectory())
[Link](" [" + fichiers[i].getName() + "]");
else
[Link](" " + fichiers[i].getName());
}
}
}
}

Nom du repertoire : fichiers

Chemin du repertoire : ressources/fichiers
Chemin absolu : /Users/oujaouraM/Documents/Workspace/cours_java/ressources/fichiers
Droit de lecture : true
Droit d'ecriture : true
contenu du repertoire
[Link]
.DS_Store
[Link]
[Link]
[Link]
[Link]
testFile
 Les fichiers à accès direct
42
¨ Les fichiers à accès direct permettent un accès rapide à un enregistrement contenu dans un
fichier.
¨ Le plus simple pour utiliser un tel type de fichier est qu'il contienne des enregistrements de
taille fixe mais ce n'est pas obligatoire. Il est possible dans un tel type de fichier de mettre à
jour directement un de ses enregistrements.
¨ La classe RamdonAccessFile encapsule les opérations de lecture/écriture d'un tel fichier. Elle
implémente les interfaces DataInput et DataOutput.
¨ Elle possède deux constructeurs qui attendent en paramètres le fichier à utiliser (sous la forme
d'un nom de fichier ou d'un objet de type File qui encapsule le fichier) et le mode d'accès.
¨ Le mode est une chaîne de caractères qui doit être égale à « r » ou « rw » selon que le mode
est lecture seule ou lecture/écriture.
¨ Ces deux constructeurs peuvent lever les exceptions suivantes :
¤ FileNotFoundException si le fichier n'est pas trouvé
¤ IllegalArgumentException si le mode n'est pas «r» ou «rw»
¤ SecurityException si le gestionnaire de sécurité empêche l'accès aux fichiers dans le mode précisé
¨ La classe RandomAccessFile possède de nombreuses méthodes writeXXX() pour écrire des
types primitifs dans le fichier.
¨ Elle possède aussi de nombreuses classes readXXX() pour lire des données primitives dans le
fichier.
 Les fichiers à accès direct : Lecture
Ecriture (Exemple)
43
import [Link];
public class RandomAccessFileWriteExemple {
public static void main(String[] args) {
try {
RandomAccessFile monFichier = new RandomAccessFile("ressources/fichiers/[Link]", "rw");
for (int i = 0; i < 10; i++) {
[Link](i * 100);
}
[Link]();
} catch (Exception e) {
[Link]();
}
}
}
import [Link];
public class RandomAccessFileReadExemple {
public static void main(String[] args) {
try {
RandomAccessFile monFichier = new RandomAccessFile("ressources/fichiers/[Link]", "rw");
for (int i = 0; i < 10; i++) {
[Link]([Link]());
}
[Link]();
} catch (Exception e) {
[Link]();
}
}
}

0
100
.....
900
 Les fichiers à accès direct : position du
curseur (Exemple)
44

¨ Pour naviguer dans le fichier, la classe utilise un pointeur qui indique la

position dans le fichier où les opérations de lecture ou de mise à jour doivent
être effectuées.
¨ La méthode getFilePointer() permet de connaître la position de ce pointeur
et la méthode seek() permet de le déplacer.
¨ La méthode seek() attend en paramètre un entier long qui représente la
position, dans le fichier, précisée en octets. La première position commence à
zéro.
import [Link];
public class RandomAccessFileCurseurExemple {
public static void main(String[] args) {
try {
RandomAccessFile monFichier = new RandomAccessFile("ressources/fichiers/[Link]", "rw");
// 5 représente le sixième enregistement puisque le premier commence à 0
// 4 est la taille des données puisqu'elles sont des entiers de type int
// (codé sur 4 octets)
[Link](5 * 4);
[Link]([Link]());
[Link]();
} catch (Exception e) {
[Link]();
}
}
}

500
 La classe [Link]
45

¨ La classe [Link], ajoutée dans Java SE 6, permet un accès à la

console du système d'exploitation pour permettre la saisie ou l'affichage de
données.
¨ Cette nouvelle classe fait usage des flux de type Reader et Writer ce qui
permet une gestion correcte des caractères.
¨ La classe System possède une méthode console() qui permet d'obtenir une
instance de la classe Console.
¨ La méthode printf() permet de formater et d'afficher des données.
¨ La méthode readLine() permet la saisie d'une ligne de données dont les
caractères sont affichés sur la console.
¨ La méthode readPassword() est identique à la méthode readLine() mais les
caractères saisis ne sont pas affichés sur la console.
¨ La méthode [Link] () peut renvoyer null si aucun périphérique de
console n'est présent. Cela surprend les utilisateurs lorsqu'ils exécutent leur
code dans un environnement de développement intégré.
 La classe [Link] (Exemple)
46

//import [Link];
public class ConsoleExemple {

public static void main(String args[]) {

String string = "La façade nécessaire";
[Link](string);
[Link]().printf("%s\n", string);
[Link]("Votre login :");
String log = [Link]().readLine();
[Link]("Mot de passe :");
char[] pass = [Link]().readPassword();
[Link]("Login: "+log+"\nPasswod: "+[Link]());
}
}

¨ Il faut compiler et exécuter l’exemple via l’invite de

commande.
 Hiérarchie des classes d'entrées/sorties
sous forme de flux d'octets
47
 Hiérarchie des flux de texte Unicode en
entrée et en sortie
48
 Quelques classes de flux en entrée avec
quelques liaisons possibles
49
 Quelques classes de flux en sortie avec
quelques liaisons possibles
50