10-C-D-001

Télécharger au format doc, pdf ou txt
Télécharger au format doc, pdf ou txt
Vous êtes sur la page 1sur 9

ROYAUME DU MAROC

Office de la Formation Professionnelle et de la Promotion du Travail

Utilisation des fichiersTitre du document

DIRECTION RECHERCHE ET INGENIERIE DE FORMATION


SECTEUR NTIC
ROYAUME DU MAROC

Office de la Formation Professionnelle et de la Promotion du Travail

DIRECTION RECHERCHE ET INGENIERIE DE FORMATION


SECTEUR NTIC
Les fichiers

Sommaire

1. Saisir des données envoyées par le clavier..................................................2


1.1. Première méthode.................................................................................. 2
1.2. Deuxième méthode................................................................................ 3
2. Lire ou écrire des caractères dans un fichier................................................4
3. Écrire dans un fichier texte...........................................................................5
4. Lire dans un fichier texte..............................................................................5
4.1. Premier exemple.................................................................................... 5
4.2. Deuxième exemple................................................................................. 6

Document Millésime Page


OFPPT @ 832289118.doc juillet 08 1-9
Les fichiers

1.Saisir des données envoyées par le


clavier
Si vous voulez lire des données envoyées tout simplement par le clavier, nous vous indiquons
deux méthodes illustrées ci-dessous.

Les deux programmes d'illustration ont pour objectif de lire des entiers envoyés par
l'intermédiaire du clavier, et d'en faire la somme. Leurs cahiers des charges diffèrent
uniquement sur la façon d'indiquer la fin de la saisie.

Nous notons en rouge les instructions significatives sur le thème de la saisie des données au
clavier.

1.1. Première méthode


On utilise deux classes de java.io, la classe InputStreamReader et la
classe BufferedReader.

La classe InputStreamReader admet un constructeur InputStreamReader(InputStream),


c'est-à-dire un constructeur qui admet en paramètre un flot d'entrée. System.in est une
instance de la classe InputStream. Avec une instance de InputStreamReader, on ne peut
grosso modo que lire des caractères un à un.

La classe BufferedReader a un constructeur qui prend en argument une instance de Reader


dont hérite la classe InputStreamReader. Cette classe permet en particulier de lire une ligne
d'un texte, mais en revanche, on ne peut pas lui demander de lire un entier, un double etc...

On lit ici ce qui est envoyé par le clavier ligne par ligne et on découpe le contenu de chaque
ligne avec un StringTokenizer pour récupérer les entiers attendus.

L'utilisateur devra taper return deux fois de suite pour interrompre la saisie.

Voici le programme que nous proposons.

import java.io.*;
import java.util.*;

class SaisieClavier
{
public static void main (String[] argv) throws IOException,
NumberFormatException
{
int somme = 0;
String ligne;
StringTokenizer st;
BufferedReader entree = new BufferedReader
(new InputStreamReader(System.in));

ligne = entree.readLine();
while(ligne.length() > 0)
{
st = new StringTokenizer(ligne);

Document Millésime Page


OFPPT @ 832289118.doc juillet 08 2-9
Les fichiers
while(st.hasMoreTokens())
somme += Integer.parseInt(st.nextToken());
ligne = entree.readLine();
}
System.out.println("La somme vaut : "+somme);
}
}
Voici une execution :
$ java SaisieClavier
3 1
2

La somme vaut : 6

1.2. Deuxième méthode


On utilise ici une instance de StreamTokenizer qui est un analyseur
syntaxique plutôt rudimentaire.

Un constructeur de la classe StreamTokenizer prend en paramêtre une instance de Reader.

La méthode nextToken() de la classe StreamTokenizer retourne le type de l'unité lexicale


suivante, type qui est caractérisé par une constante entière. Cela peut être :

 TT_NUMBER si l'unité lexicale représente un nombre. Ce nombre se trouve


alors dans le champ nval de l'instance de StreamTokenizer. Ce champ est
de type double.
 TT_WORD si l'unité lexicale représente une chaîne de caractères. Cette
chaîne se trouve alors dans le champ sval de l'instance du
StreamTokenizer.
 TT_EOL si si l'unité lexicale représente une fin de ligne. La fin de ligne n'est
reconnue comme unité lexicale que si on a utilisé l'instruction

nomDuStreamTokenizer.eolIsSignificant(true);

TT_EOF s'il s'agit du signe de fin de fichier.

import java.io.*;

class EssaiStream
{
public static void main (String[] argv) throws IOException
{
int somme = 0;
int type;
StreamTokenizer entree= new StreamTokenizer
(new InputStreamReader(System.in));
String fin=new String("fin");

System.out.println("Donnez vos entiers, terminez avec fin");


while(true)
{
type=entree.nextToken();
if (type==StreamTokenizer.TT_NUMBER)
somme += (int)entree.nval;

Document Millésime Page


OFPPT @ 832289118.doc juillet 08 3-9
Les fichiers
else if ((type == StreamTokenizer.TT_WORD)&&
(fin.equals(entree.sval)))
break;
}
System.out.println("La somme vaut : " + somme);
}
}

Voici une execution :

Donnez vos entiers, terminez avec fin


1 -2 bonjour 4
3 fin 2
La somme vaut : 6

2.Lire ou écrire des caractères dans un fichier

La classe FileReader permet de lire des caractères dans un fichier.

La classe FileWriter permet d'écrire des caractères dans un fichier.

Le programme ci-dessous écrit une chaîne de caractères dans un fichier nommé


copie_essai.txt puis copie le fichier essai.txt caractère par caractère dans le fichier
copie_essai.txt.

import java.io.*;

class LireEcrireTexte
{
public static void main(String[] argv) throws IOException
{
FileReader lecteur;
FileWriter ecrivain;
int c;

lecteur = new FileReader("essai.txt");


ecrivain = new FileWriter("copie_essai.txt");
ecrivain.write("copie de essai.txt\n");
while((c = lecteur.read()) != -1)
ecrivain.write(c);
lecteur.close();
ecrivain.close();
}
}
Si le fichier essai.txt contient :
bonjour
rebonjour
le fichier copie_essai.txt contient après exécution :
copie de essai.txt
bonjour
rebonjour

Document Millésime Page


OFPPT @ 832289118.doc juillet 08 4-9
Les fichiers
3.Écrire dans un fichier texte

On utilise ici une instance de PrintWriter, dont un constructeur prend en argument un


Writer dont la classe BufferedWriter hérite.
Vous pouvez utiliser avec une instance de PrintWriter les méthodes print et println de la
même façon qu'avec System.out (qui est de la classe PrintStream). La classe PrintWriter
(qui hérite de la classe Writer) ne fait qu'améliorer la classe PrintStream (qui hérite de
OutputStream).

On aurait pu plus simplement initialiser ecrivain par :

ecrivain = new PrintWriter(new FileWriter(argv[0]));


mais alors les écritures n'utiliseraient pas de mémoire-tampon.
import java.io.*;

class EcrireFichierTexte
{
public static void main(String[] argv) throws IOException
{
PrintWriter ecrivain;
int n = 5;

ecrivain = new PrintWriter(new BufferedWriter


(new FileWriter(argv[0])));

ecrivain.println("bonjour, comment cela va-t-il ?");


ecrivain.println("un peu difficile ?");
ecrivain.print("On peut mettre des entiers : ");
ecrivain.println(n);
ecrivain.print("On peut mettre des instances de Object : ");
ecrivain.println(new Integer(36));
ecrivain.close();
}
}
Apres execution, le fichier indiqué contient :
bonjour, comment cela va-t-il ?
un peu difficile ?
On peut mettre des entiers 5
On peut mettre des instances de Object : 36

4.Lire dans un fichier texte


4.1. Premier exemple
Il s'agit ici de lire un fichier de type texte ligne par ligne et de reproduire ce qui est lu
directement à l'écran. On compose pour cela un BufferdReader avec un FileReader.

Cet exemple est particulièrement simple.

Document Millésime Page


OFPPT @ 832289118.doc juillet 08 5-9
Les fichiers
import java.io.*;

class LireLigne
{
public static void main(String[] argv) throws IOException
{
BufferedReader lecteurAvecBuffer = null;
String ligne;

try
{
lecteurAvecBuffer = new BufferedReader
(new FileReader(argv[0]));
}
catch(FileNotFoundException exc)
{
System.out.println("Erreur d'ouverture");
}
while ((ligne = lecteurAvecBuffer.readLine()) != null)
System.out.println(ligne);
lecteurAvecBuffer.close();
}
}
A l'exécution, on obtient en sortie exactement le contenu du fichier dont
le nom est indiqué sur la ligne de commande.

4.2. Deuxième exemple


Il s'agit maintenant de lire des entiers dans un fichier ne contenant que
des entiers et d'en faire la somme.

Les classes utilisées ici l'on déjà été dans les exemples précédents.

import java.io.*;

class LireEntiers
{
public static void main (String[] argv) throws IOException
{
int somme = 0;
FileReader fichier = new FileReader(argv[0]);

StreamTokenizer entree = new StreamTokenizer(fichier);


while(entree.nextToken() == StreamTokenizer.TT_NUMBER)
{
somme += (int)entree.nval;
}
System.out.println("La somme vaut : " + somme);
fichier.close();
}
}
Avec un fichier contenant :
5 3 6 2 7
-10 23
on obtient :
La somme vaut : 36

Document Millésime Page


OFPPT @ 832289118.doc juillet 08 6-9
Les fichiers
Pour approfondir le sujet….
Proposition de références utiles permettant d’approfondir le thème abordé

Sources de référence
Citer les auteurs et les sources de référence utilisées pour l’élaboration du
support

Document Millésime Page


OFPPT @ 832289118.doc juillet 08 7-9

Vous aimerez peut-être aussi