www.infkoffler.com - Site de cours d'informatique

Accueil

Java Standard Edition

Java EE 5

Visual Basic .Net 2005

Cours Javascript - DOM - DHTML

Nouveautés sur le site

Contacts

Accueil > Java Standard Edition > E/S(12):Flux de caractères: FileReader et FileWriter

____________________________________________________________________________________________________

Connexion

Les entrées-sorties(12) - Les flux de caractères: FileReader et FileWriter

Sommaire :

I) FileReader (java.io)
II) FileWriter (java.io)
III)Code source complet de l'exemple
IV) Téléchargement de l'exemple

FileReader et FileWriter (java.io) sont les classes pour lire et écrire dans des fichiers de caractères.
Il est conseillé, pour plus d'efficacité, de les empaqueter avec un BufferedReader ou BufferedWriter.
Par exemple:
Dans le cas du BufferedWriter, ne pas oublier de faire un close ou flush à la fin, pour écrire réellement dans le flux les dernières données du buffer.

On peut remarquer que FileReader et FileWriter sont en fait des InputStreamReader et InputStreamWriter: pour lire ou écrire dans un fichier de caractères, on est obligé de passer par les flux d'octets.

I) FileReader (java.io)

FileReader hérite de InputStreamReader, qui est une classe héritant de Reader et qui permet de pouvoir lire un InputStream.

Trois méthodes ont été rajoutées: les trois constructeurs de FileReader.
Ces 3 constructeurs construisent tout simplement un objet FileInputStream correspondant, et utilise le constructeur de InputStreamReader qui prend un InputStream.

/*
 * @(#)FileReader.java	1.16 05/11/17
 *
 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package java.io;

/**
 * Convenience class for reading character files.  The constructors of this
 * class assume that the default character encoding and the default byte-buffer
 * size are appropriate.  To specify these values yourself, construct an
 * InputStreamReader on a FileInputStream.
 *
 * <p><code>FileReader</code> is meant for reading streams of characters.
 * For reading streams of raw bytes, consider using a
 * <code>FileInputStream</code>.
 *
 * @see InputStreamReader
 * @see FileInputStream
 *
 * @version 	1.16, 05/11/17
 * @author	Mark Reinhold
 * @since	JDK1.1
 */
public class FileReader extends InputStreamReader {

/**
    * Creates a new <tt>FileReader</tt>, given the name of the
    * file to read from.
    *
    * @param fileName the name of the file to read from
    * @exception  FileNotFoundException  if the named file does not exist,
    *                   is a directory rather than a regular file,
    *                   or for some other reason cannot be opened for
    *                   reading.
    */
    public FileReader(String fileName) throws FileNotFoundException {
	super(new FileInputStream(fileName));
    }

/**
    * Creates a new <tt>FileReader</tt>, given the <tt>File</tt> 
    * to read from.
    *
    * @param file the <tt>File</tt> to read from
    * @exception  FileNotFoundException  if the file does not exist,
    *                   is a directory rather than a regular file,
    *                   or for some other reason cannot be opened for
    *                   reading.
    */
    public FileReader(File file) throws FileNotFoundException {
	super(new FileInputStream(file));
    }

/**
    * Creates a new <tt>FileReader</tt>, given the 
    * <tt>FileDescriptor</tt> to read from.
    *
    * @param fd the FileDescriptor to read from
    */
    public FileReader(FileDescriptor fd) {
	super(new FileInputStream(fd));
    }

}

II) FileWriter (java.io)

Marche exactement sur le principe de FileReader.

Ici, 5 méthodes ont été ajoutées: les 5 constructeurs de FileWriter.

Les 5 constructeurs appellent tous le constructeur de OutputStreamWriter qui prend un OutputStream en paramètre.

package java.io;

/**
 * Convenience class for writing character files.  The constructors of this
 * class assume that the default character encoding and the default byte-buffer
 * size are acceptable.  To specify these values yourself, construct an
 * OutputStreamWriter on a FileOutputStream.
 *
 * <p>Whether or not a file is available or may be created depends upon the
 * underlying platform.  Some platforms, in particular, allow a file to be
 * opened for writing by only one <tt>FileWriter</tt> (or other file-writing
 * object) at a time.  In such situations the constructors in this class
 * will fail if the file involved is already open.
 *
 * <p><code>FileWriter</code> is meant for writing streams of characters.
 * For writing streams of raw bytes, consider using a
 * <code>FileOutputStream</code>.
 *
 * @see OutputStreamWriter
 * @see FileOutputStream
 *
 * @version 	1.19, 05/11/17
 * @author	Mark Reinhold
 * @since	JDK1.1
 */

public class FileWriter extends OutputStreamWriter {

/**
     * Constructs a FileWriter object given a file name.
     *
     * @param fileName  String The system-dependent filename.
     * @throws IOException  if the named file exists but is a directory rather
     *                  than a regular file, does not exist but cannot be
     *                  created, or cannot be opened for any other reason
     */
    public FileWriter(String fileName) throws IOException {
	super(new FileOutputStream(fileName));
    }

/**
     * Constructs a FileWriter object given a file name with a boolean
     * indicating whether or not to append the data written.
     *
     * @param fileName  String The system-dependent filename.
     * @param append    boolean if <code>true</code>, then data will be written
     *                  to the end of the file rather than the beginning.
     * @throws IOException  if the named file exists but is a directory rather
     *                  than a regular file, does not exist but cannot be
     *                  created, or cannot be opened for any other reason
     */
    public FileWriter(String fileName, boolean append) throws IOException {
	super(new FileOutputStream(fileName, append));
    }

/**
     * Constructs a FileWriter object given a File object.
     *
     * @param file  a File object to write to.
     * @throws IOException  if the file exists but is a directory rather than
     *                  a regular file, does not exist but cannot be created,
     *                  or cannot be opened for any other reason
     */
    public FileWriter(File file) throws IOException {
	super(new FileOutputStream(file));
    }

/**
     * Constructs a FileWriter object given a File object. If the second
     * argument is <code>true</code>, then bytes will be written to the end
     * of the file rather than the beginning.
     *
     * @param file  a File object to write to
     * @param     append    if <code>true</code>, then bytes will be written
     *                      to the end of the file rather than the beginning
     * @throws IOException  if the file exists but is a directory rather than
     *                  a regular file, does not exist but cannot be created,
     *                  or cannot be opened for any other reason
     * @since 1.4
     */
    public FileWriter(File file, boolean append) throws IOException {
        super(new FileOutputStream(file, append));
    }

/**
     * Constructs a FileWriter object associated with a file descriptor.
     *
     * @param fd  FileDescriptor object to write to.
     */
    public FileWriter(FileDescriptor fd) {
	super(new FileOutputStream(fd));
    }

}

III) Code source de l'exemple

package main;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * 
 * @author sabri Koffler pour www.infkoffler.com, exemple du cours Java Standard
 * @version 1.0 (de l'application) / 17/11/2008
 * Créé 17/11/2008
 * Programme d'exemple pour les entrées-sorties(10): Les classes
 * java.io.FileReader et java.io.FileWriter
 *
 */
public class Main {
	
	/**
	 * Méthode de test. Va créer un fichier avec le nom en paramètre, de deux lignes,
	 * contenant "Bonjour, je suis réveillé.\r\nEt voilà la deuxième ligne!\r\n"
	 * @param pNomFichier Le nom du fichier à créer
	 */
	private static void creerMonFichier(String pNomFichier) {
		BufferedWriter monFluxSortie;
		String maString = "Bonjour, je suis réveillé.\r\nEt voilà la deuxième ligne!\r\n";
		try {
			monFluxSortie = new BufferedWriter(new FileWriter(pNomFichier));
		} catch (IOException e) {
			e.printStackTrace();
			return;
		}
		
		try {
			monFluxSortie.write(maString);
		} catch (IOException e) {
			e.printStackTrace();
			return;
		}
		finally { //exécuté même si exception
				//de monFluxSortie.write(maString), et malgré le return.
				//Dans ce cas, le bloc finally sera exécuté juste avant le return
			try {
				monFluxSortie.close();
			} catch (IOException e) {
				e.printStackTrace();
				return;
			}
		}
	}
	
	/**
	 * Affiche dans la console le contenu de tout fichier texte
	 * @param pNomFichier
	 */
	private static void afficherFichierTexte(String pNomFichier) {
		BufferedReader monFluxEntree;
		String ligneLue;
		try {
			monFluxEntree= new BufferedReader(new FileReader(pNomFichier));
		} catch (FileNotFoundException e) {
			e.printStackTrace();
			return;
		}
		
		try {
			ligneLue = monFluxEntree.readLine(); //vaut null si fin de fichier
		} catch (IOException e) {
			e.printStackTrace();
			try {
				monFluxEntree.close();
			} catch (IOException eClose) {
				eClose.printStackTrace();
				return;
			}
			return;
		}
		
		while (ligneLue!=null) {
			System.out.println(ligneLue);
			try {
				ligneLue = monFluxEntree.readLine();
			} catch (IOException e) {
				e.printStackTrace();
				try {
					monFluxEntree.close();
				} catch (IOException e2) {
					e2.printStackTrace();
					return;
				}
				return;
			}
		} //fin while	
		try {
			monFluxEntree.close();
		} catch (IOException e) {
			e.printStackTrace();
			return;
		}			
		
	}
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String nomFichier="C:\\Users\\jean\\testWriter.txt";
		Main.creerMonFichier(nomFichier);
		Main.afficherFichierTexte(nomFichier);
	}

}

IV) Téléchargement de l'exemple

Projet d'exemple, V1.0

RETOUR HAUT