// ne pas faire attention aux imports, ils sont faits automatiquement par eclipse
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/**
* Cette classe permet de parcourir un fichier texte et d'en afficher le
* contenu à l'écran.
*/
public class Parcours {
///////////////////////////////////////////////////////////////////////////
// méthode main
public static void main(String[] args) {
/* Il faut créer un dossier "tests-java" dans C:\
* cela nous permettra d'y faire des tests sans risquer d'endommager
* d'autres fichiers par erreur.
*/
String cheminDesFichiers = "C:\\tests-java\\";
/* Il faut ensuite créer un fichier "mon_fichier.txt" dans C:\tests-java
* le fichier peut rester vide ou peut contenir du texte (provenant par
* exemple du site : http://www.lipsum.com).
*/
String cheminFichierCourant = cheminDesFichiers + "mon_fichier.txt";
// appel de la méthode statique qui va nous permettre d'afficher le fichier
afficherFichier(cheminFichierCourant);
}
///////////////////////////////////////////////////////////////////////////
/**
* Cette méthode permet d'afficher le contenu d'un fichier de chemin 'chemin'
* sur la sortie console. La méthode utilisée est celle du BufferedReader.
*/
public static void afficherFichier(String chemin) {
/* A ce stade, on sait juste qu'on veut afficher un fichier...
* mais la question est : comment ? Qu'est-ce qui existe en Java et qui
* peut nous aider efficacement à cette tâche ?
* Sur Google, recherchez ceci "java read file"
* Résultat : http://java.sun.com/javase/6/docs/api/java/io/BufferedReader.html
* La documentation explique ce qu'est un objet BufferedReader mais pour nous,
* nous allons nous contenter de savoir qu'un "reader" permet de parcourir un
* fichier en lecture (contrairement au BufferedWriter qui permettra d'écrire
* un fichier partie par partie, voir le tutorial adéquat).
* Buffered signifie "avec utilisation d'un tampon (mémoire)". Pour l'instant,
* nous n'allons pas nous préoccuper de ceci mais encore une fois, pour en
* savoir plus, sur Google, recherchez "buffer" : http://fr.wikipedia.org/wiki/Buffer !
*
* En tapant ceci : BufferedReader bReader = new BufferedReader(
* eclipse nous fait savoir qu'il faut au constructeur un objet de type Reader
* (http://java.sun.com/javase/6/docs/api/java/io/Reader.html)
* La documentation de BufferedReader (voir plus haut) nous donne un exemple
* d'utilisation (que nous allons suivre mais que nous allons faire en deux étapes :
* 1) créer l'objet FileReader (classe enfant de Reader)
* 2) créer l'objet BufferedReader avec dans l'argument du constructeur le FileReader)
*
* Le FileReader sera construit en utilisant le contructeur qui prend un String (le
* chemin du fichier). Ce String est le paramètre de notre méthode : chemin.
* Il faudra néanmoins gérer les exceptions à ce niveau : FileNotFoundException !
*/
try {
FileReader fReader = new FileReader(chemin);
BufferedReader bReader = new BufferedReader(fReader);
/* A ce stade, nous savons que nous avons un objet qui va nous permettre de
* parcourir un fichier mais nous ne connaissons pas encore la méthode qu'il
* va falloir appliquer au BufferedReader => il faut aller voir la documentation !
*
* Nous trouvons la méthode (dans le "Method Summary") :
* String readLine()
* Reads a line of text.
* Et plus bas :
* Returns:
* A String containing the contents of the line, not including
* any line-termination characters, or null if the end of the
* stream has been reached
*
* Cela se déchiffre comme suit : String signifie que la méthode readLine()
* renvoie un String. Les parenthèses vides signifient qu'il n'y a pas d'argument
* à donner. Le texte en dessous est la description. En français, cela donne :
* "Lit une ligne de texte." => nous y sommes donc !
*
* Quand readLine() renvoit null, nous savons que nous sommes à la fin du fichier.
*
* Bien sûr, pour parcourir un fichier, comme un tableau ou une liste ou toute
* autre structure linéaire, nous allons utiliser une boucle.
* Quand est-ce que celle-ci s'arrête ? Pour un tableau, c'est à la fin du...
* tableau. Pour un fichier, c'est à la fin du... fichier (pas de miracles).
*/
String ligne = null;
while( (ligne = bReader.readLine()) != null) {
/* Tant que bReader.readLine() (stockée dans ligne) est différent de null, cela
* signifie que quelque chose a été lu.
* readLine() peut lancer une IOException, nous la catchons plus bas.
*/
// arrivé ici, tout va bien : nous pouvons afficher la ligne lue
System.out.println(ligne);
}
/* Après avoir traité un fichier (lecture/écriture), il faut toujours prendre
* la bonne habitude de le libérer. Pour ce faire, nous cherchons la méthode de
* BufferedReader qui nous permet de le faire et on trouve :
* void close()
* Closes the stream and releases any system resources associated with it.
*/
bReader.close();
} catch (FileNotFoundException e) {
System.out.println("Erreur ouverture fichier en lecture. Arrêt du programme.");
System.exit(-1); // pour arrêter le programme et quitter avec le code d'erreur -1
} catch (IOException e) {
System.out.println("IOException pour cause indéterminée. Arrêt du programme.");
System.exit(-1);
}
}
}
Articles liés
- Parcourir et transférer contenu fichier texte
- Divers traitements sur fichiers texte
- Lister et afficher éléments d’une liste
