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.

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).

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.

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);
                                            }
                                        }
                                    }
                            

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().

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
                            

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);
                                            }
                                        }
                                    }
                            

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.