Groupe3 Java Lecture Fichier

ECOLE POLYTECHNIQUE DE NIAMEY

Programmation Structurée
420‐168‐SH
GRI2
GROUPE 3
LECTURE-ECRITURE
DANS UN FICHIER
Travail à Présenté à:
Mme Songoti
Préparé par :
♣ NAMALKA Oumarou
♣ MAIKOREMA Abdoulkarim
♣ NOUHOU Kakale
Session 4 : février 2011
GROUPE 3 : NAMALKA OMAR ‐KARIM MAIKOREMA‐NOUHOU KAKALE

Sommaire
I INTRODUCTION ............................................................................................................................... 3
II FICHIER .............................................................................................................................................. 4
1 Organisation des fichiers .................................................................................................................. 4
1.1 Première Structure ..................................................................................................................... 4
1.2 deuxième structure .................................................................................................................... 4
2 Type d’accès ..................................................................................................................................... 5
2.1 accès direct ................................................................................................................................ 5
2.2 accès séquentiel : ....................................................................................................................... 5
III ENTREE SORTIE ............................................................................................................................. 6
1-java.io ............................................................................................................................................... 6
2 La classe java.lang.System ............................................................................................................... 7
3classe file ........................................................................................................................................... 7
3.1 lire dans un fichier .................................................................................................................... 7
3.2 écrire dans un fichier ................................................................................................................. 7
IV CAS PRATIQUE .............................................................................................................................. 8
1 ECRITURE DANS UN FICHIER ................................................................................................... 8
EXEMPLE1 .................................................................................................................................... 8
2 LECTURE DANS UN FICHIER ..................................................................................................... 9
EXEMPLE 2 ................................................................................................................................... 9
V CONCLUSION ................................................................................................................................. 11
VI WEBOGRAPHIE ............................................................................................................................. 12

I INTRODUCTION
Le langage de programmation java fournit un ensemble de classe permettant de lire ou
d’écrire dans un fichier .nous étudierons dans ce document la classe entrée sortie qui nous
permettra de lire ou d’écrire dans un fichier.
La première partie de ce document nous parle du fichier, sa structure, son organisation,

les types d’accès, les instructions, et les stratégies de traitement.
La deuxième partie nous explique les notions d’entrée sortie (IO) en java, les
différentes classes java.io, la lecture dans un fichier et l’écriture dans un fichier.
La troisième partie est entièrement consacrée à la création d’un programme qui lit les
fichiers.


II FICHIER
Les fichiers sont des structures des données stockés sur un disque. A la différence des
données gérées en mémoire par les programmes (entiers, booleans, tableaux, chaines
etc.….)qui sont perdues a la fin du programme.
Au niveau physique un fichier est composé d’une suite de blocs disque de taille constante
gérée par le système d’exploitation qui offre au programme une vue logique du fichier
Au niveau logique un fichier est une suite d’octet qui représente des informations de
différents types : tableaux, entiers, nombres reels, boolean, objet.
Java offre une large palette de classe et méthode pour utiliser les fichiers .toutes ses classes se
trouvent dans le paquetage java.io.
1 Organisation des fichiers

Il existe deux grandes variantes pour structurer les données au sein d’un fichier texte : la
délimitation, ou les champs de largeur fixe.
1.1 Première Structure

Dite délimitée, Elle utilise un caractère de délimitation, qui indique le début d’ un champ et
celui du champ suivant. Il va de soi que ce caractère de délimitation doit être strictement
interdit à l’intérieur de chaque champ, faute de quoi la structure devient proprement illisible.
Son avantage est qu’il occupe moins d’espace mémoire, parc qu’il y’a aucun espace perdu.
Mais il possède un inconvénient majeur, qui est la lenteur d’accès.
Exemple :
"karim";"maikorema";0022790984578;"k.maikorema@etu.epn.ne"
"nouhou";"kakale";002279090987;"n.kakale@etu.epn.ne"
1.2 deuxième structure

Dite champs de largeur fixe, Il n’y a pas de caractère de délimitation, mais on sait que les x
premiers caractères de chaque ligne stockent des données dans un champs, les y suivants
dans un autre, etc. Cela impose bien entendu de ne pas saisir un renseignement plus long que
le champ prévu pour l’accueillir.
A l’inverse de la première structure, elle est gourmande en mémoire puisque les fichiers
possède plein de trou .mais présente un accès rapide.
Exemple :
namalka omar 22709873 n.omar@etu.epn.ne

2 Type d’accès
L’organisation des données au sein du fichier s’effectue selon deux grands choix stratégiques.
Mais il existe une autre ligne de partage des fichiers : le type d’accès, autrement dit la manière
dont la machine va pouvoir aller rechercher les enregistrements.
Le choix du type d’accès n’est pas un choix qui concerne le fichier lui-même, mais
uniquement la manière dont il va être traité par la machine. C’est donc dans le programme, et
seulement dans le programme, que l’on choisit le type d’accès souhaité.
On distingue :
2.1 accès direct

On peut accéder directement à l’enregistrement de son choix, en précisant le numéro de cet
enregistrement.
I l est clair que l’accès direct possède tous les avantages et aucun inconvénient. Sa
programmation est immensément plus simple et moins fastidieuse que celle de l’accès
séquentiel. Mas le gros problème de l’accès direct, c’est qu’il n’est pas géré de la même
manière selon le type de machine
2.2 accès séquentiel :

On ne peut accéder qu’à l’enregistrement suivant celui qu’on vient de lire.
’Accès séquentiel, est entièrement piloté par le langage lui-même. Il est donc laborieux à
programmer, offre une sécurité absolue de portabilité. la plupart des programmeurs
s’astreignent encore à utiliser ce type d’accès.

III ENTREE SORTIE
Les entrées sortie permettent la communication du programme avec les périphériques,
un programme a souvent besoin d’importer une information depuis une source externe ou
d’exporter de l’information vers une destination externe .cette dernière peut être dans un
fichier, sur un disque dur, en mémoire, ou dans un autre programme . En Java, les entrées
sorties sont réalisées par l'intermédiaire de la librairie standard java.io
1-java.io
Java fournit un ensemble de classe permettant de lire et d'écrire dans des fichiers. Ces classes
sont regroupées dans un package. Pour les fichiers, il s'agit du package java.io. Pour utiliser
les classes d'un package, il faut l'"importer", en utilisant, au début du fichier .java, le mot-clé
import, suivi du nom du package, puis d'un point et d'une étoile. Ainsi, pour importer les
classes du package java.io, on commence le fichier par: import java.io.*
Le paquetage java.io contient plus de 40 classes;
Les classes les plus importantes pour traiter les flux d'entrées sont:
• InputStream: super-classe (abstraite) pour la lecture depuis les flux d'entrées;

• InputStreamReader: classe qui agit comme une passerelle entre les flux d'entrée
binaires et les flux de caractères pour la lecture;
• DataInputStream: classe permettant de lire des fichiers binaires en utilisant les types
primitifs de Java;
• BufferedInputStream: classe qui permet d'accéder à un flux d'entrée à travers un
tampon;
• BufferedReader: classe permettant de lire des chaînes de caractères d'un flux;
• FileInputStream: classe permettant de lire des fichiers de données quelconques;
• FileReader: classe permettant de lire des fichiers de texte.
Les classes les plus importantes pour traiter les flux de sortie sont:
• OutputStream: super-classe (abstraite) pour les l'écriture sur des flux de sortie;
• OutputStreamWriter: classe qui agit comme une passerelle en encodant un flux de
caractères sous la forme d'un flux d'octets;
• DataOutputStream: classe permettant d'écrire des fichiers binaires en utilisant les types
primitifs de Java;
• BufferedOutputStream: classe qui permet d'alimenter un flux de sortie en passant par
un tampon;
• BufferedWriter: classe permettant d'écrire des chaînes de caractères dans un flux;
• FileOutputStream: classe permettant d'écrire des fichiers de données quelconques;
• FileWriter: classe permettant d'écrire des fichiers de texte;
• PrintStream: classe obsolète, remplacée par PrintWriter;
• PrintWriter: classe qui permet d'écrire les valeurs des types primitifs sous forme de
chaînes de caractères sur un flux de sortie;

2 La classe java.lang.System
Elle possède trois flux standards de caractères:
• public static final InputStream in : représente un flux d'entrée standard déjà ouvert, en
général le clavier;
• public static final PrintStream out : représente un flux de sortie standard déjà ouvert,
en générale une console ou une fenêtre simulant une console;
• public static final PrintStream err : représente un flux de sortie standard déjà ouvert
pour les messages d'erreurs; il est parfois identique à out.
3classe file
3.1 lire dans un fichier

la classe FileReader permet la lecture dans un fichier. Plus précisément, on crée un
nouvel objet de cette classe pour chaque fichier que l'on veut lire, en utilisant le constructeur
qui prend en paramètre le nom du fichier à lire. La création de cet objet à pour effet d'ouvrirle
fichier en lecture. Pour ouvrir le fichier projet.txt en lecture, on peut par exemple faire:
Exemple :
FileReader fichier = new FileReader("projet.txt");
Une fois le fichier ouvert, on utilise l'objet ainsi créé pour lire des caractères dans le fichier,
grâce à la méthode read() de la classe FileReader. Attention cependant cette méthode ne
renvoie pas un caractère, mais un entier qui correspond au code du caractère ou bien la valeur
-1 si on a atteint la fin du fichier. Il faut donc stocker le code du caractère lu dans un entier,
testé si l'entier vaut ou pas -1, puis le convertir en caractère, grâce à la conversion (char). Le
code suivant utilise l'objet créé ci-dessus pour lire un caractère dans le fichier toto.txt et
l'afficher à l'écran, sauf si on a atteint la fin du fichier:
3.2 écrire dans un fichier

La classe FileWriter nous permet d’ecrire dans un fichier. De même que dans le cas de
la lecture, on crée un nouvel objet de cette classe pour chaque fichier dans lequel on veut
écrire. Cette fois ci, la création de l'objet permet d'ouvrir le fichier en écriture.
Attention: Si le fichier existe déjà, il est écrasé au moment de l'ouverture en écriture.
Pour ouvrir le fichier projet1.txt en écriture:
Exemple 6
FileWriter fichier2 = new FileWriter("projet1.txt");
Une fois le fichier ouvert en écriture, il suffit d'utiliser la méthode write(int) ou la

write(String) pour écrire dans le fichier. Par exemple le code suivant utilise l'objet
précédemment créé pour écrire le caractère 'a' suivit de la chaîne "bcde" dans le fichier
projet1.txt:

IV CAS PRATIQUE
1 ECRITURE DANS UN FICHIER
EXEMPLE1
import java.io.*;
import java.util.*;
class EcritureFichier{
public static void main(String[] args){
Scanner src= new Scanner(System.in);
String nomFichier ;
System.out.println("Donnez le nom du fichier a creer : ") ;
nomFichier = src.next();
FileWriter fw=null;
BufferedWriter bw=null;
PrintWriter pw=null;
try{
// File nomFichier = new File("bibi");
fw=new FileWriter(nomFichier,true);
bw=new BufferedWriter( fw);
pw=new PrintWriter(bw);
pw.write("BONJOUR ");
pw.write("LES PROFESSIONNELS DE LA PROGRAMMATION VOUS ");
pw.write("PRESENTE ");
bw.newLine();
pw.write("LECTURE ET ECRITURE DANS UN FICHIER ");
GROUPE 3 :NAMALKA OMAR ‐KARIM MAIKOREMA‐NOUHOU KAKALE


}catch(IOException e){
System.out.println("Problème àl'écriture du fichier");
}finally{
pw.close();
2 LECTURE DANS UN FICHIER
EXEMPLE 2
import java.io.*;
import java.util.*;
class LectureFichier{
public static void main(String[] args){
Scanner src= new Scanner(System.in);
String nomFichier="pratique.txt" ;
System.out.println ("Donnez le nom du fichier a lire : ") ;
nomFichier = src.nextLine();
try{
FileReader fr=new FileReader(nomFichier);
BufferedReader br=new BufferedReader(fr);
String ligne=br.readLine();
while(ligne!=null){
System.out.println(ligne);
ligne=br.readLine();


br.close();
}catch(FileNotFoundException e){
System.out.println("Fichier non trouvé");
catch(IOException e){
System.out.println("Problème à la lecture du fichier");


V CONCLUSION
Il est très important de maitriser le fonctionnement du fichier avant de se lancer dans la

programmation.la connaissance de la structure du fichier permet la gestion des ressources
mémoire dans les programmes.les classes FileReader et FileWriter sont une des classes les
plus utilisés dans le package java.io.


VI WEBOGRAPHIE
Les sites web suivants ont été consultés pour la conception de ce document.
http://www.netalya.com/fr/Algo‐intro.asp
http://www.iro.umontreal.ca/~dift1020/cours/ift1020/communs/Cours/C13/iojava.pdf
http://www710.univ‐lyon1.fr/~ecoquery/enseignement/java/es_java.html
http://anisfrikha.developpez.com/tutoriel/java‐io/

Groupe3 Java Lecture Fichier

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Groupe3 Java Lecture Fichier

Uploaded by

Copyright:

Available Formats

ECOLE POLYTECHNIQUE DE NIAMEY

Session 4 : février 2011

1 Organisation des fichiers .................................................................................................................. 4

1.1 Première Structure ..................................................................................................................... 4

1.2 deuxième structure .................................................................................................................... 4

2.1 accès direct ................................................................................................................................ 5

2.2 accès séquentiel : ....................................................................................................................... 5

III ENTREE SORTIE ............................................................................................................................. 6

3.1 lire dans un fichier .................................................................................................................... 7

3.2 écrire dans un fichier ................................................................................................................. 7

1 ECRITURE DANS UN FICHIER ................................................................................................... 8

2 LECTURE DANS UN FICHIER ..................................................................................................... 9

La première partie de ce document nous parle du fichier, sa structure, son organisation,

1 Organisation des fichiers

1.1 Première Structure

1.2 deuxième structure

namalka omar 22709873 n.omar@etu.epn.ne

2.1 accès direct

2.2 accès séquentiel :

• InputStream: super-classe (abstraite) pour la lecture depuis les flux d'entrées;

3.1 lire dans un fichier

FileReader fichier = new FileReader("projet.txt");

3.2 écrire dans un fichier

FileWriter fichier2 = new FileWriter("projet1.txt");

Une fois le fichier ouvert en écriture, il suffit d'utiliser la méthode write(int) ou la

1 ECRITURE DANS UN FICHIER

public static void main(String[] args){

Scanner src= new Scanner(System.in);

System.out.println("Donnez le nom du fichier a creer : ") ;

// File nomFichier = new File("bibi");

bw=new BufferedWriter( fw);

pw.write("LES PROFESSIONNELS DE LA PROGRAMMATION VOUS ");

pw.write("LECTURE ET ECRITURE DANS UN FICHIER ");

System.out.println("Problème àl'écriture du fichier");

2 LECTURE DANS UN FICHIER

public static void main(String[] args){

Scanner src= new Scanner(System.in);

System.out.println ("Donnez le nom du fichier a lire : ") ;

FileReader fr=new FileReader(nomFichier);

BufferedReader br=new BufferedReader(fr);

System.out.println("Fichier non trouvé");

System.out.println("Problème à la lecture du fichier");

Il est très important de maitriser le fonctionnement du fichier avant de se lancer dans la

You might also like