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(2):FileInputStream et FileOutputStream

____________________________________________________________________________________________________

Connexion

Java SE - Les entrées sorties(2) - Les fichiers binaires: Les classes java.io.FileInputStream et java.io.FileOutputStream

Sommaire :

I)Généralités
II) La classe java.io.FileInputStream
   II-1) Les méthodes native
   II-2) Les contructeurs de la classe FileInputStream
   II-3) La classe java.io.FileDescriptor
   II-4) La classe java.io.File et la classe java.io.FileSystem
III) La classe java.io.FileOutputStream
   III-1) Les contructeurs de la classe FileOutputStream
   III-2) Les méthodes native de FileOutputStream
IV)Code source complet de l'exemple
V) Téléchargement de l'exemple

I) Généralités

On utilise les classes java.io.FileInputStream et java.io.FileOutpoutStream, pour lire des octets bruts. Pour lire et écrire des caractères, utiliser FileReader et FileWriter.
java.io.FileInputStream et java.io.FileOutputStream héritent directement de java.io.InputStream et java.io.OutputStream respectivement

II) La classe java.io.FileInputStream

Classe utilisée pour la lecture de fichiers d'octets bruts.

II-1) Les méthodes native

Elle contient un certain nombre de méthodes natives, pour des primitives de base. Comme:
ou encore(méthode privée utilisée par les deux autres méthodes read):
Ces méthodes natives n'ont pas été écrites en Java, elles l'ont été dans un langage dépendant du système d'exploitation, par exemple le langage C ou C++.
La machine virtuelle possède le code compilé de ces méthodes( C compilé par exemple, toujours du langage machine) dans des dlls dont elle possède une version différente selon le système d'exploitation(la machine virtuelle installée est différente selon le système d'exploitation).

On peut comprendre que tout ne peut pas être écrit en Java. Il arrive un moment où on a besoin de primitives de base, qui ne peuvent pas être écrites en Java, comme par exemple la lecture d'un octet d'un fichier, ou de n octets d'un fichier.

II-2) Les contructeurs de la classe FileInputStream

Il y a plusieurs constructeurs:
public FileInputStream(String name) fait uniquement:
Ce constructeur utilise, comme on peut le constater, le constructeur ci-dessous, avec un File en paramètre.
Remarque intéressante: le constructeur public FileInputStream(File file) fait un (FileInputStream.)open du fichier(donc le constructeur public FileInputStream(String name) aussi).

et
Ce constructeur sera détaillé au paragraphe suivant.

II-3) La classe java.io.FileDescriptor

Revenons au constructeur
Le FileDescriptor est un objet système-dépendant( c'est à dire dont la valeur a été établie par le système d'exploitation sous-jacent).
Le File Descriptor représente une connexion existante à un fichier ouvert, ou une socket ouverte, ou une autre connexion d'entrée/sortie active. On ne peut pas créer nous même de FileDescriptor pour un fichier(ou socket, etc) particulier ouvert, il faut l'obtenir par une méthode java native qui va initialiser le champ privé int fd d'un objet FileDescriptor qu'on lui aurait passé en paramètre. Ce champ privé fd est à initialiser par exemple en C, avec le résultat de la fonction C open.
A noter que la classe FileInputStream possède un attribut privé fd qui est un FileDescriptor. Ce champs est initialisé avec un new FileDescriptor() par les deux constructeurs FileInputStream(String name) et FileInputStream(File file), ce qui crée un objet fd avec un filedescriptor invalide( qui vaut -1!). Le seul constructeur public de FileDescriptor construit, en effet, un objet FileDescriptor invalide, car une application java n'a pas à construire d'elle-même de FileDescriptor initialisé.
L'objet FileDescriptor est un objet qui sert d'interface entre un langage dépendant du système comme C ou C+, et java, et ainsi pour transmettre une valeur de descripteur de fichier obtenue directement par le système d'exploitation sous-jacent.

II-4) La classe java.io.File et la classe java.io.FileSystem

LA classe java.io.File est une représentation abstraite de noms de fichiers(ou de répertoires) qui sont indépendants du système d'exploitation utilisé.

La conversion entre un nom de fichier abstrait et un nom de fichier réelle est système-dépendante.

A noter un attribut static privé fs, représentant le file system:
La classe java.io.FileSystem possède une méthode normalize qui est utilisée par public File(String pathname). Cette méthode effectue une conversion du nom de fichier réelle vers un nom de fichier abstrait. Ainsi, dans le constructeur File(String pathname), on a:
La méthode normalize de la classe FileSystem:
A noter que la méthode (FileSystem.)getFileSystem est native:
Une méthode native peut parfaitement retourner des objets qui sont des instances(initialisées) d'une de nos classes java(Ici un objet de la classe java.io.FileSystem est créé par une méthode native)

III) La classe java.io.FileOutputStream

Elle hérite de java.io.OutputStream

C'est une classe qui ressemble à FileInputStream.

Elle a aussi un attribut privé fd:

III-1) Les contructeurs de la classe FileOutputStream

Il utilise le constructeur FileOutputStream(File file, boolean append).
Il utilise le constructeur FileOutputStream(File file, boolean append).
Il utilise le constructeur FileOutputStream(File file, boolean append).

III-2) Les méthodes native de FileOutputStream

Les primitives de base sont native, ce qui semble parfaitement logique.

/**
     * Opens a file, with the specified name, for writing.
     * @param name name of file to be opened
     */
    private native void open(String name) throws FileNotFoundException;

/**
     * Opens a file, with the specified name, for appending.
     * @param name name of file to be opened
     */
    private native void openAppend(String name) throws FileNotFoundException;

/**
     * Writes the specified byte to this file output stream. Implements 
     * the <code>write</code> method of <code>OutputStream</code>.
     *
     * @param      b   the byte to be written.
     * @exception  IOException  if an I/O error occurs.
     */
    public native void write(int b) throws IOException;

/**
     * Writes a sub array as a sequence of bytes.
     * @param b the data to be written
     * @param off the start offset in the data
     * @param len the number of bytes that are written
     * @exception IOException If an I/O error has occurred.
     */
    private native void writeBytes(byte b[], int off, int len) throws IOException;

//(...)
	
	private native void close0() throws IOException;

Deux méthodes public d'écriture, et une de fermeture utlisent ces méthodes native:

IV)Code source complet de l'exemple

package main;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 
 * @author sabri Koffler pour www.infkoffler.com, exemple du cours Java Standard
 * @version 1.0 (de l'application) / 2/11/2008
 * Créé 2/11/2008
 * Programme d'exemple pour les entrées-sorties(2): Les classes
 * java.io.FileInputStream et java.io.FileOutputStream
 *
 */
public class Main {
	/**
	 * Méthode de test. Va créer un fichier avec le nom en paramètre,
	 * contenant 100 octets valant de 0 à 99.
	 * @param pNomFichier Le nom du fichier à créer
	 */
	private static void creerMonFichier(String pNomFichier) {
		//Ecriture d'un fichier avec 100 octets dedans, qui ont
		//pour valeur de 0 à 99
		FileOutputStream monFluxSortie;
		byte tab[] = new byte[100];
		try {
			monFluxSortie = new FileOutputStream(pNomFichier);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
			return;
		}
		
		for (int i=0;i<100;i++) {
			tab[i] = (byte)i;
		}
		try {
			monFluxSortie.write(tab);
		} catch (IOException e) {
			e.printStackTrace();
			return;
		}
		finally { //exécuté même si exception
				//de monFluxSortie.write(tab), 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;
			}
		}
	}
	
	/**
	 * Méthode de test. Va lire le contenu du fichier et l'afficher
	 * @param pNomFichier
	 */
	private static void lireMonFichier(String pNomFichier) {
		FileInputStream monFluxEntree;
		byte[] tab = new byte[100];
		try {
			monFluxEntree= new FileInputStream(pNomFichier);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
			return;
		}
		
		try {
			monFluxEntree.read(tab);
		} catch (IOException e) {
			e.printStackTrace();
			return;
		}
		finally { //exécuté même si exception
					//de monFluxEntree.read(tab), et malgré le return
				//Dans ce cas, le bloc finally sera exécuté juste avant le return
			try {
				monFluxEntree.close();
			} catch (IOException e) {
				e.printStackTrace();
				return;
			}
		}
		for (int i = 0; i<100; i++) {
			System.out.println(tab[i]);
		}
		
	}
	
	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) {
		String nomFichier="C:\\Users\\jean\\testOutput.bin";
		Main.creerMonFichier(nomFichier);
		Main.lireMonFichier(nomFichier); //affiche les nombres de 0 à 100
	}

}

V) Téléchargement de l'exemple

Projet d'exemple, V1.0

RETOUR HAUT