Java

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

Lecture et écriture dans un fichier en Java

Avant qu'une application puisse utiliser un fichier de données, elle doit ouvrir le fichier. Une application Java ouvre un fichier en créant un objet et en y associant un flux d'octets. De même, lorsque vous terminez d'utiliser un fichier, le programme devrait fermer le fichier, c'est à dire le rendre inaccessible à votre application.

Si vous ne fermez pas un fichier d'entrée (un fichier à partir duquel vous lisez des données), il n'y a généralement pas de conséquences graves; les éléments de données existent toujours dans le fichier. Cependant, si vous ne fermez pas un fichier de sortie(un fichier dans lequel vous écrivez des données), les données risquent de devenir inaccessibles.

Alors que les utilisateurs considèrent un fichier comme une série d’enregistrements, chaque enregistrement contenant des champs de données, Java n’attribue pas automatiquement cette signification au contenu d’un fichier. Au lieu de cela, Java considère simplement un fichier comme une série d'octets. Lorsque vous effectuez une opération de saisie dans une application, vous pouvez imaginer les octets entrant dans votre programme à partir d'un périphérique d'entrée via un flux(stream), qui fonctionne comme un pipeline ou un canal.

Un stream est un objet et, comme tous les objets, les stream ont des données et des méthodes. Les méthodes vous permettent d'effectuer des actions telles que l'ouverture, la fermeture, la lecture et l'écriture.

Les opérations d’entrée et de sortie font généralement partie des opérations les plus lentes de tous les systèmes informatiques en raison des limitations imposées par le matériel. Pour cette raison, les programmes professionnels utilisent souvent des tampons (buffers).

L'utilisation d'un tampon pour accumuler les entrées ou les sorties avant d'émettre la commande E/S réelle améliore les performances du programme. Lorsque vous utilisez un tampon de sortie, vous le videz parfois avant de le fermer. Le vidage efface tous les octets qui ont été envoyés à une mémoire tampon de sortie, mais n'ont pas encore été sortie d'un périphérique matériel.

Utilisation des Classes E/S de Java

La figure suivante illustre une relation hiérarchique partielle de certaines des classes utilisées par Java pour les opérations d'entrée et de sortie (E/S).

Classes E/S de Java

ClasseDescription
InputStreamClasse abstraite contenant des méthodes pour effectuer des entrées (E)
FileInputStreamEnfant de InputStream qui offre la possibilité de lire à partir de fichiers sur disque
BufferedInputStreamEnfant de FilterInputStream, qui est un enfant de InputStream; BufferedInputStream gère les entrées à partir du périphérique d’entrée standard (ou par défaut) du système, généralement le clavier.
OutputStreamClasse abstraite contenant des méthodes pour effectuer une sortie (S)
FileOutputStreamEnfant de OutputStream qui vous permet d'écrire sur des fichiers de disque
BufferedOutputStreamEnfant de FilterOutputStream, qui est un enfant de OutputStream; BufferedOutputStream gère les entrées provenant du périphérique de sortie standard (ou par défaut) du système, généralement le console.
PrintStreamEnfant de FilterOutputStream, qui est un enfant de OutputStream; System.out est un objet PrintStream
ReaderClasse abstraite pour la lecture de flux de caractères; les seules méthodes qu'une sous-classe doit implémenter sont read(char[], int, int) et close()
BufferedReaderLit le texte à partir d'un flux d'entrée de caractères et met en mémoire tampon les caractères pour permettre une lecture efficace des caractères, des tableaux et des lignes
BufferedWriterÉcrit du texte dans un flux de sortie de caractères en mettant en mémoire tampon les caractères pour permettre une écriture efficace des caractères, des tableaux et des lignes

Comme son nom l'indique, la classe OutputStream peut être utilisée pour produire une sortie. Le tableau suivant présente certaines des méthodes courantes de la classe.

MéthodeDescription
void close()Ferme le flux de sortie et libère toutes les ressources système associées au flux
void flush()Vide le flux de sortie; si des octets sont mis en mémoire tampon, ils seront écrits
void write(byte[] b)Écrit tous les octets dans le flux de sortie à partir du tableau d'octets spécifié
void write(byte[] b, int off, int len)Écrit des octets dans le flux de sortie à partir du tableau d'octets spécifié, en commençant par la position off pour une longueur len de caractères

Vous pouvez utiliser OutputStream pour écrire tout ou partie d'un tableau d'octets. Lorsque vous avez fini d'utiliser un OutputStream, vous souhaitez généralement le vider et le fermer.

La classe System de Java contient un objet PrintStream appelé System.out; vous avez largement utilisé cet objet, ainsi que ses méthodes print() et println(). Outre System.out, la classe System définit un objet PrintStream nommé System.err.

La sortie de System.err et System.out peut aller au même périphérique. En fait, System.err et System.out sont tous les deux dirigés par défaut vers le console.

La différence est que System.err est généralement réservé aux messages d'erreur et System.out est réservé à une sortie valide. Vous pouvez diriger System.err ou System.out vers un nouvel emplacement, tel qu'un fichier de disque ou une imprimante. Par exemple, vous voudrez peut être conserver un journal des messages d'erreur générés par un programme, mais diriger la sortie standard vers un fichier sur disque.

Bien que vous n’ayez généralement pas besoin de le faire, vous pouvez créer votre propre objet OutputStream et lui affecter System.out.

Exemple 1 :
                                    import java.io.*;

                                    public class Test {
                                        public static void main(String args[]) {
                                            String s = "Hello, world";
                                    
                                            // convertit String en un tableau d'octets
                                            byte[] data = s.getBytes();
                                            
                                            OutputStream output = null;
                                            try {
                                                output = System.out;
                                                output.write(data);
                                                output.flush();
                                                output.close();
                                            } catch (Exception e) {
                                                System.out.println("Erreur : " + e);
                                            }
                                        }
                                    }
                            
Hello, world

Ecrire dans un fichier

Au lieu d'affecter le périphérique de sortie standard à OutputStream, vous pouvez affecter un fichier. Pour ce faire, vous pouvez construire un objet BufferedOutputStream et l'affecter au OutputStream. Si vous souhaitez modifier le périphérique de sortie d'une application, vous ne devez pas modifier l'application mais il faut juste affecter un nouvel objet au OutputStream. Le reste de la logique reste le même.

Java vous permet d'affecter un fichier à un objet Stream afin que la sortie d'écran et la sortie de fichier fonctionnent exactement de la même manière.

Vous pouvez créer un fichier accessible en écriture à l'aide de la méthode newOutputStream() de la classe Files. Vous passez un argument Path et un argument StandardOpenOption à cette méthode. La méthode crée un fichier s'il n'existe pas déjà, ouvre le fichier en écriture et renvoie un OutputStream qui peut être utilisé pour écrire des octets dans le fichier.

le tableau suivant montre les arguments StandardOpenOption que vous pouvez utiliser comme deuxième argument de la méthode newOutputStream().

ArgumentDescription
WRITEOuvre le fichier pour l'écriture
APPENDAjoute les nouvelles données à la fin du fichier; utiliser cette option avec WRITE ou CREATE
TRUNCATE_EXISTINGTronque le fichier existant sur 0 octet pour que le contenu du fichier soit remplacé; utiliser cette option avec l'option WRITE
CREATE_NEWCrée un nouveau fichier seulement s’il n’existe pas; lève une exception si le fichier existe déjà
CREATEOuvre le fichier s'il existe ou crée un nouveau fichier sinon.
DELETE_ON_CLOSESupprime le fichier lorsque le flux est fermé; utilisé le plus souvent pour les fichiers temporaires qui n'existent que pour la durée du programme

Si vous ne spécifiez aucune option et que le fichier n'existe pas, un nouveau fichier est créé. Si le fichier existe, il est tronqué. En d'autres termes, ne spécifier aucune option revient à spécifier CREATE et TRUNCATE_EXISTING.

Exemple 2 :
                                    import java.io.*;
                                    import java.nio.file.*;
                                    // charger les options
                                    import static java.nio.file.StandardOpenOption.*;
                                    
                                    public class Test {
                                        public static void main(String args[]) {
                                            Path chemin = Paths.get("intro.txt");
                                            String s = "Hello, world";
                                    
                                            // convertit String en un tableau d'octets
                                            byte[] data = s.getBytes();
                                    
                                            OutputStream output = null;
                                            try {
                                                // Un objet BufferedOutputStream est affecté à la référence OutputStream.
                                                output = new BufferedOutputStream(Files.newOutputStream(chemin, CREATE));
                                                // Ecrire dans le fichier
                                                output.write(data);
                                    
                                                // vider le tampon
                                                output.flush();
                                    
                                                // fermer le fichier
                                                output.close();
                                    
                                            } catch (Exception e) {
                                                System.out.println("Message " + e);
                                            }
                                        }
                                    }
                            
                                // contenu de intro.txt
                                Hello, world
                            

Lecture d'un fichier

Vous utilisez un InputStream comme vous utilisez un OutputStream. Pour ouvrir un fichier en lecture, vous pouvez utiliser la méthode newInputStream() de la classe Files. Cette méthode accepte un paramètre Path et renvoie un flux capable de lire des octets à partir d'un fichier.

Exemple 3 :
                                    import java.io.*;
                                    import java.nio.file.*;
                                    
                                    public class Test {
                                        public static void main(String args[]) {
                                            Path chemin = Paths.get("intro.txt");
                                            InputStream input = null;
                                            try {
                                                input = Files.newInputStream(chemin);
                                                
                                                BufferedReader reader = new BufferedReader(new InputStreamReader(input));
                                                String s = null;
                                                s = reader.readLine();
                                                System.out.println(s);
                                                input.close();
                                    
                                            } catch (IOException e) {
                                                System.out.println("Message " + e);
                                            }
                                        }
                                    }
                            
Hello, world

Un BufferedReader lit une ligne de texte à partir d'un flux d'entrée de caractères, mettant en mémoire tampon les caractères afin que la lecture soit plus efficace.

Si vous aviez besoin de lire et d’afficher plusieurs lignes du fichier dans le programme, vous pouvez utiliser une boucle comme celle-ci:

                                while(s = reader.readLine() != null){
                                    System.out.println(s);
                                }
                            

Cette boucle lit et affiche en continu les lignes du fichier jusqu'à ce que la méthode readLine() retourne null, indiquant qu'il n'y a plus de données disponibles.

Lorsque vous utilisez la classe BufferedReader, vous devez importer le package java.io dans votre programme. Le tableau suivant présente quelques méthodes utiles de BufferedReader.

MéthodeDescription
close()Ferme le flux et toutes les ressources qui lui sont associées
read()Lit un seul caractère
read(char[] buffer, int off, int len)Lit les caractères dans une partie d'un tableau à partir de la position off pour les len caractères
readLine()Lit une ligne de texte
skip(long n)Ignore le nombre de caractères spécifié

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :