Écrire dans un fichier Java – 4 façons d’écrire dans un fichier en Java

Java offre plusieurs façons d’écrire dans un fichier. Nous pouvons utiliser FileWriter, BufferedWriter, java 7 Files et FileOutputStream pour écrire un fichier en Java.

Java Write to File

Jetons un bref coup d’œil sur les quatre options que nous avons pour l’opération d’écriture de fichiers Java.

1. FileWriter: FileWriter est la façon la plus simple d’écrire un fichier en Java. Il fournit une méthode de écriture surchargée pour écrire un entier, un tableau d’octets et une chaîne dans le fichier. Vous pouvez également écrire une partie de la chaîne ou du tableau d’octets à l’aide de FileWriter. FileWriter écrit directement dans les fichiers et ne doit être utilisé que lorsque le nombre d’écritures est faible.
2. BufferedWriter: BufferedWriter est presque similaire à FileWriter mais il utilise un tampon interne pour écrire des données dans le fichier. Ainsi, si le nombre d’opérations d’écriture est plus élevé, les opérations IO réelles sont moins nombreuses et les performances sont meilleures. Vous devriez utiliser BufferedWriter lorsque le nombre d’opérations d’écriture est plus élevé.
3. FileOutputStream: FileWriter et BufferedWriter sont destinés à écrire du texte dans le fichier, mais lorsque vous avez besoin d’écrire des données de flux brut dans un fichier, vous devriez utiliser FileOutputStream pour écrire un fichier en Java.
4. Files: Java 7 a introduit la classe utilitaire Files et nous pouvons écrire un fichier en utilisant sa fonction write. En interne, elle utilise OutputStream pour écrire un tableau d’octets dans le fichier.

Exemple d’écriture de fichier en Java

Voici un exemple montrant comment nous pouvons écrire un fichier en Java en utilisant FileWriter, BufferedWriter, FileOutputStream et Files en Java. WriteFile.java

package com.journaldev.files;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Paths;

public class WriteFile {

    /**
     * This class shows how to write file in java
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) {
        String data = "I will write this String to File in Java";
        int noOfLines = 10000;
        writeUsingFileWriter(data);
        
        writeUsingBufferedWriter(data, noOfLines);
        
        writeUsingFiles(data);
        
        writeUsingOutputStream(data);
        System.out.println("DONE");
    }

    /**
     * Use Streams when you are dealing with raw data
     * @param data
     */
    private static void writeUsingOutputStream(String data) {
        OutputStream os = null;
        try {
            os = new FileOutputStream(new File("/Users/pankaj/os.txt"));
            os.write(data.getBytes(), 0, data.length());
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    /**
     * Use Files class from Java 1.7 to write files, internally uses OutputStream
     * @param data
     */
    private static void writeUsingFiles(String data) {
        try {
            Files.write(Paths.get("/Users/pankaj/files.txt"), data.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * Use BufferedWriter when number of write operations are more
     * It uses internal buffer to reduce real IO operations and saves time
     * @param data
     * @param noOfLines
     */
    private static void writeUsingBufferedWriter(String data, int noOfLines) {
        File file = new File("/Users/pankaj/BufferedWriter.txt");
        FileWriter fr = null;
        BufferedWriter br = null;
        String dataWithNewLine=data+System.getProperty("line.separator");
        try{
            fr = new FileWriter(file);
            br = new BufferedWriter(fr);
            for(int i = noOfLines; i>0; i--){
                br.write(dataWithNewLine);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                br.close();
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * Use FileWriter when number of write operations are less
     * @param data
     */
    private static void writeUsingFileWriter(String data) {
        File file = new File("/Users/pankaj/FileWriter.txt");
        FileWriter fr = null;
        try {
            fr = new FileWriter(file);
            fr.write(data);
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            //fermer les ressources
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

Ce sont les méthodes standard pour écrire un fichier en Java et vous devriez en choisir une en fonction des exigences de votre projet. C’est tout pour l’exemple d’écriture de fichier en Java.

Vous pouvez consulter davantage d’exemples d’IO Java dans notre référentiel GitHub.