Vous êtes sur la page 1sur 7

Matière : Java 2

Ecole Polytechnique Sousse Classe : 4 Génie télecom


Enseignant : Mr.Trabelsi Selem TP N° 3 : Les Flux : généralités

Les flux séquentiels : Ces flux peuvent être associés à des fichiers, des tableaux, ou des
connexions réseau. Deux «styles» de flux séquentiels :

 les flux d’octets en lecture et en écriture (InputStream, OutputStream).


 les flux de caractères en lecture et en écriture (Reader, Writer).

A. InputStreamReader
La classe InputStreamReader établit un pont entre les flux d'octets et les flux de caractères.
Cette classe permet de lire des octets et les traduit en caractères en utilisant un décodage
spécifique. L'appel de la méthode read() d'un InputStreamReader va effectuer la lecture de 1
ou plusieurs octets.

Le constructeur :

InputStreamReader(InputStream in) Crée un InputStreamReader qui utilise


le charset par défaut.

L'environnement d'exécution Java supporte en standard plusieurs jeux d'encodages de


caractères (charset) dont :

 US-ASCII : encodage des caractères sur 7 bits


 ISO-8859-1 (latin 1) : encodage des caractères sur 8 bits dans un seul octet pour la plupart
des caractères des langues européennes de l'ouest excepté le caractère €
 UTF-8 : encodage des caractères sur 8 bits dans 1 à 4 octets. Les caractères ASCII

B. File
La classe File encapsule les fonctionnalités de gestion de fichier : Suppression, renommage,
date de la dernière modification, etc …

Constructeurs :

File(String chemin) Crée un nouveau File associé au nom chemin.

Méthodes :

boolean canRead() Renvoie vrai si le fichier peut être lu, et faux sinon.
boolean canWrite() Renvoie vrai si le fichier peut être écrit, et faux sinon.
int compareTo(File pathname) Comparaison des 2 chemins
Création d’un nouveau fichier vide, et renvoie vrai si le nouveau fichier n’existait
boolean createNewFile()
pas avant sa création.
boolean delete() Supprime le fichier
void deleteOnExit() Supprime le fichier à la fin de l’exécution de la machine virtuelle.
boolean exists() Renvoie vrai si et seulement si le fichier existe.
String getAbsolutePath() Retourne le chemin absolu
String getCanonicalPath() Retourne le chemin absolu
String getName() Retourne le nom du fichier.
String getPath() Retourne le chemin du fichier.
boolean isDirectory() Retourne vrai s’il s’agit d’un répertoire et faux sinon.
boolean isFile() Retourne vrai s’il s’agit d’un fichier "normal" et faux sinon.
Retourne la date de la dernière modification sous forma de long. Date d = new
long lastModified()
Date(f .lastModified()) ;
long length() La longueur du fichier, en octets.
Retourne la liste des fichiers contenus dans le répertoire spécifié par le File. Si le
String[] list()
File n'est pas un répertoire le tableau retourné vaut null.
Retourne la liste des fichiers contenus dans le répertoire spécifié par le File. Si le
File[] listFiles()
File n'est pas un répertoire le tableau retourné vaut null.
boolean mkdir() Crée un répertoire.
Crée un répertoire, et tous ses parents nécessaires. L'appel de mkdir avec
boolean mkdirs()
un File constitué de "\\" retourne false.
Renomme un fichier. retourne false si le file dest existe déjà, et le renommage
boolean renameTo(File dest)
n'est pas effectué.
boolean setReadOnly() Marque le fichier en lecture seule

1) Décrire brièvement les méthodes de la classe File utilisé ainsi que le résultat de ce code

import java.io.File;
public class File {
public static void main(String[] args) {
//Création de l'objet File
File f = new File("test.txt");
System.out.println("Chemin absolu du fichier : " + f.getAbsolutePath());
System.out.println("Nom du fichier : " + f.getName());
System.out.println("Est-ce qu'il existe ? " + f.exists());
System.out.println("Est-ce un répertoire ? " + f.isDirectory());
System.out.println("Est-ce un fichier ? " + f.isFile());
System.out.println("Affichage des lecteurs à la racine du PC : ");
for(File file : f.listRoots())
{ System.out.println(file.getAbsolutePath());
try {
int i = 1;
//On parcourt la liste des fichiers et répertoires
for(File nom : file.listFiles()){
//S'il s'agit d'un dossier, on ajoute un "/"
System.out.print("\t\t" + ((nom.isDirectory()) ? nom.getName()+"/" :
nom.getName())); if((i%4) == 0){
System.out.print("\n"); }
i++; }
System.out.println("\n");
} catch (NullPointerException e) {
//L'instruction peut générer une NullPointerException
//s'il n'y a pas de sous-fichier !
} } }}

C. FileInputStream et FileOutputStream
C'est par le biais des objets FileInputStream et FileOutputStream que nous allons pouvoir :
 lire un fichier ;
 écrire dans un fichier.

2) Exécuter le code suivant et expliquer son rôle ?

import java.io.*;
public class FileStream {
public static void main(String[] args) {
// Nous déclarons nos objets en dehors du bloc try/catch

FileInputStream fis = null;


FileOutputStream fos = null;
try {

// On instancie nos objets : // fis va lire le fichier // fos va écrire dans le nouveau !

fis = new FileInputStream(new File("test.txt"));


fos = new FileOutputStream(new File("test2.txt"));
// On crée un tableau de byte pour indiquer le nombre de bytes lus à chaque tour de boucle

byte[] buf = new byte[8];


// On crée une variable de type int pour y affecter le résultat de // la lecture Vaut -1 quand c'est
fini

int n = 0;
// Tant que l'affectation dans la variable est possible, on boucle // Lorsque la lecture du fichier
est terminée l'affectation n'est // plus possible ! // On sort donc de la boucle

while ((n = fis.read(buf)) >= 0) {


// On écrit dans notre deuxième fichier avec l'objet adéquat

fos.write(buf);
// On affiche ce qu'a lu notre boucle au format byte et au // format char

for (byte octet : buf) {


System.out.print("\t" + octet + "(" + (char) octet + ")");
System.out.println(""); }
//Nous réinitialisons le buffer à vide

//au cas où les derniers bytes lus ne soient pas un multiple de

//Ceci permet d'avoir un buffer vierge à chaque lecture et ne pas avoir de doublon en fin de fichier

buf = new byte[8]; }


System.out.println("Copie terminée !");
fis.close(); fos.close();
} catch (FileNotFoundException e) {
// Cette exception est levée si l'objet FileInputStream ne trouve // aucun fichier
} catch (IOException e) {
// Celle-ci se produit lors d'une erreur d'écriture ou de lecture } }}

3) Quel est le type de l’information utilisé avec la classe FileInputStream et


FileOutputStream
4) Donner la condition pour que l’objet FileInputStream fonctionne ? Que se passe-t-il si
cette condition n’est pas respectée ?
D. Les objets FilterInputStream et FilterOutputStream

Ces deux classes sont en fait des classes abstraites. Elles définissent un comportement global
pour leurs classes filles qui, elles, permettent d'ajouter des fonctionnalités aux flux
d'entrée/sortie ! La figure suivante schématisant leur hiérarchie.
Vous pouvez voir qu'il existe quatre classes filles héritant de FilterInputStream (de même
pourFilterOutputStream (les classes dérivant de FilterOutputStream ont les mêmes
fonctionnalités, mais en écriture)):
 DataInputStream : offre la possibilité de lire directement des types primitifs
(double, char,int) grâce à des méthodes comme readDouble(), readInt()…
 BufferedInputStream ou BufferedReader: cette classe permet d'avoir un tampon à
disposition dans la lecture du flux. En gros, les données vont tout d'abord remplir le
tampon, et dès que celui-ci est plein, le programme accède aux données.
Exemple :

FileInputStream fis = new FileInputStream(new File("java2.txt"));

DataInputStream dis = new DataInputStream(fis);

BufferedInputStream bis = new BufferedInputStream(dis);

//Ou en condensé :

BufferedInputStream bis = new BufferredInputStream( new DataInputStream ( new


FileInputStream( new File("java2.txt"))));

E. DataInputStream et DataOutputStream
import java.io.*;
public class TestData {
public static void main(String[] args) {
//Nous déclarons nos objets en dehors du bloc try/catch
DataInputStream dis;
DataOutputStream dos;
try {
dos = new DataOutputStream(

new FileOutputStream ("fff.txt"));


//Nous allons écrire chaque type primitif
dos.writeBoolean(true);
dos.writeByte(100);
dos.writeChar('C');
dos.writeDouble(12.05);
dos.writeFloat(100.52f);
dos.writeInt(1024);
dos.writeLong(123456789654321L);
dos.writeShort(2);
dos.close();
//On récupère maintenant les données !
dis = new DataInputStream(

new FileInputStream("fff.txt"));
System.out.println(dis.readBoolean());
System.out.println(dis.readByte());
System.out.println(dis.readChar());
System.out.println(dis.readDouble());
System.out.println(dis.readFloat());
System.out.println(dis.readInt());
System.out.println(dis.readLong());
System.out.println(dis.readShort());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
5) Expliquer le résultat de ce code et préciser quels sont les types primitifs utilisés ainsi que
leurs méthodes ?
6) Est-ce que on peut ajouter une chaine de caractère au fichier de sortie ? Pourquoi ? Si non
que suggérer vous ?
F. Ecrire et lecture des lignes dans des fichiers
7) Créer "read.txt" et écrire plusieurs lignes dans ce fichier ?
8) Implémenter ce code et décrire son fonctionnement ?
9) Préciser le rôle de la classe BufferedReader

import java . io .*;


class read {
public static void main ( String args []) throws IOException {
String thisLine ;
String [] fullText = new String [10];

FileInputStream fis = new FileInputStream ( "read.txt" );


BufferedReader myInput = new BufferedReader( new InputStreamReader(fis) );
while (( thisLine = myInput.readLine()) != null ) {
System . out . println ( thisLine );

}
}}

10) Développer ce code et décrire son fonctionnement ? Préciser le rôle de la classe


PrintWriter

import java . io .*;


class write {
public static void main ( String args []) throws IOException {

BufferedReader exemple = new BufferedReader(new InputStreamReader(System.in));


System.out.println("Entrer une chaine par le clavier :");
String chaine = exemple.readLine();
System.out.println("la chaine saisie est "+chaine);

FileOutputStream fos = new FileOutputStream ( " theText.txt " );


PrintWriter myOutput = new PrintWriter ( fos );
myOutput . println ( chaine);
myOutput.close();
}

G. }Les objets ObjectInputStream et ObjectOutputStream


Vous devez savoir que lorsqu'on veut écrire des objets dans des fichiers, on appelle ça la «
sérialisation » : Voici la classe avec laquelle nous allons travailler :

import java.io.Serializable;
public class Game implements Serializable{
private String nom, style;
private double prix;
public Game(String nom, String style, double prix) {
this.nom = nom;
this.style = style;
this.prix = prix;
}
public String toString(){
return "Nom du jeu : " + this.nom + "\n Style de jeu : " + this.style + "\n Prix du jeu :
" + this.prix + "\n";
}
}

11) Tester le rôle de cette classe et vérifier le fichier créé


import java.io.*;
public class testserialisation {
public static void main(String[] args) {
//Nous déclarons nos objets en dehors du bloc try/catch
ObjectInputStream ois;
ObjectOutputStream oos;
try {
oos = new ObjectOutputStream(
new BufferedOutputStream(
new FileOutputStream(
new File("game.txt"))));
//Nous allons écrire chaque objet Game dans le fichier
oos.writeObject(new Game("Assassin Creed", "Aventure", 45.69));
oos.writeObject(new Game("Tomb Raider", "Plateforme", 23.45));
oos.writeObject(new Game("Tetris", "Stratégie", 2.50));
//Ne pas oublier de fermer le flux !
oos.close();
//On récupère maintenant les données !
ois = new ObjectInputStream(
new BufferedInputStream(
new FileInputStream(
new File("game.txt"))));
try {
System.out.println("Affichage des jeux :");
System.out.println("*************************\n");
System.out.println(((Game)ois.readObject()).toString());
System.out.println(((Game)ois.readObject()).toString());
System.out.println(((Game)ois.readObject()).toString());
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
ois.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

Vous aimerez peut-être aussi