Le langage Java dispose de nombreuses bibliothèques concourant à la gestion des fichiers sur une unité de stockage locale ou distante.
Effectivement, il est possible de créer, de modifier, de consulter ou de supprimer des fichiers par l'intermédiaire de plusieurs classes comprises dans le paquetage java.io (io : input/output).

Cependant, la gestion des fichiers devient problématique lorsque la portabilité contraint une application Java à fonctionner d'une manière identique sur l'ensemble des plateformes cibles. Ainsi, des problèmes de codage de caractères et de convention de nommage des chemins devront être prises en considération afin d'assurer le bon fonctionnement du programme sur les plateformers sous-jacentes.

La gestion des fichiers nécessite l'emploi de certaines classes et en particulier java.io.File et les classes de flux telles que java.io.FileReader, java.io.FileReader, java.io.FileInputStream et java.io.FileOutputStream.

Dans un premier temps, il faut créer une instance d'une classe File, laquelle sera passée en argument à un constructeur de flux binaire ou de caractères et sortant ou entrant. Cette première étape permet la création d'un chemin abstrait vers un fichier et l'ouverture d'un canal de transmission vers ce fichier. A partir de ce moment, il devient possible de lire ou écrire dans le fichier.

import java.io.*;
class GestionFichier {
    public static void main(String args[]) throws IOException {
        File cheminAbstraitEntree = new File("poeme.txt");
        FileReader fluxLectureTexte = 
                                                        new FileReader(cheminAbstraitEntree);
        int car;
        StringBuffer contenu = new StringBuffer();
        while((car = fluxLectureTexte.read()) != -1){
            System.out.print ((char)car);
            contenu.append((char)car);
        }
        fluxLectureTexte.close();

        File cheminAbstraitSortie = new File("poeme_copie.txt");
        FileWriter fluxEcritureTexte = 
                                                      new FileWriter(cheminAbstraitSortie);
        fluxEcritureTexte.write(contenu.toString());
        fluxEcritureTexte.close();
    }
}

Dans le cas de la lecture de fichier, seule un accès caractères par caractères et possible par l'intermédiaire du flux FileReader, ce qui n'est certainement pas très pratique pour le traitement d'un fichier. Ainsi, une seconde étape permet de placer en mémoire tampon les caractères lus par le flux par le truchement de la classe BufferedReader.

import java.io.*;
class GestionFichier {
    public static void main(String args[]) throws IOException {
        File cheminAbstraitEntree = new File("poeme.txt");
        FileReader fluxLectureTexte = 
                                          new FileReader(cheminAbstraitEntree);
        BufferedReader tamponLecture = 
                                          new BufferedReader(fluxLectureTexte);
        String ligne;
        StringBuffer contenu = new StringBuffer();
        while((ligne = tamponLecture.readLine()) != null){
            System.out.print (ligne);
            contenu.append(ligne);
            contenu.append("\r\n");
        }
        tamponLecture.close();
        fluxLectureTexte.close();

        File cheminAbstraitSortie = new File("poeme_copie.txt");
        FileWriter fluxEcritureTexte = 
                                            new FileWriter(cheminAbstraitSortie);
        BufferedWriter tamponEcriture = 
                                            new BufferedWriter(fluxEcritureTexte);
        tamponEcriture.write(contenu.toString());
        tamponEcriture.flush();
        tamponEcriture.close();
        fluxEcritureTexte.close();
    }
}

L'utilisation d'une mémoire tampon associée à un flux améliore sensiblement les performances d'accès aux fichiers. C'est pourquoi, il est recommandée d'utiliser les classes BufferedWriter et BufferedReader, aussi bien avec les flux sortants qu'avec les flux entrants. Par ailleurs, des fonctionnalités supplémentaires sont proposées telles que la lecture par lignes (readLine()) et l'écriture d'un séparateur de lignes (newLine()).

Précédemment, des flux réservés aux caractères ont été appliqués sur des fichiers texte, dans l'exemple ci-dessous, des flux binaires permettent de travailler sur un fichier constitué d'une séquence d'octets (bytes), en l'occurrence une image GIF (Graphic Interchange Format).

import java.io.*;
import java.util.*;
class GestionFichier {
    public static void main(String args[]) throws IOException {
        File cheminAbstraitEntree = new File("java.gif");
        FileInputStream fluxLectureBinaire = 
                                     new FileInputStream(cheminAbstraitEntree);
        BufferedInputStream tamponEntree = 
                                     new BufferedInputStream(fluxLectureBinaire);
        int oct;
        Vector contenu = new Vector();
        while((oct = fluxLectureBinaire.read()) != -1){
            System.out.print (oct);
            contenu.add(new Integer(oct));
        }
        fluxLectureBinaire.close();

        File cheminAbstraitSortie = new File("java_copie.gif");
        FileOutputStream fluxEcritureBinaire = 
                                       new FileOutputStream(cheminAbstraitSortie);
        BufferedOutputStream tamponSortie = 
                                       new BufferedOutputStream(fluxEcritureBinaire);
        for(int i = 0; i < contenu.size(); i++)
            fluxEcritureBinaire.write(
                                          ((Integer)contenu.elementAt(i)).byteValue());
        fluxEcritureBinaire.close();
    }
}

Dans le cas des fichiers binaires, il est également possible de lire des données sur un flux en utilisant une mémoire tampon chargée de récupérer une séquence d'octets importantes qui restituera son contenu lors d'appels de la méthode read(). En écriture, le fonctionnement est identique à l'exception du sens du flux et de la méthode, dans ce cas il s'agît de write().

Sommaire