Java – Écrire dans un fichier

L'une des tâches les plus courantes dans le développement de logiciels est la capacité de lire et d'écrire des fichiers. En Java, l'écriture dans un fichier est un processus simple qui peut être effectué à l'aide de classes et de méthodes intégrées. Dans cet article, nous explorerons comment écrire dans un fichier à l'aide de Java et discuterons des différentes classes et méthodes impliquées. Java fournit des classes intégrées telles que FileWriter et PrintWriter pour écrire dans un fichier en Java.

Exemple d'écriture Java dans un fichier

Pour commencer, regardons un exemple simple d'écriture dans un fichier en Java. Voici un exemple de la façon d'écrire une chaîne dans un fichier en Java à l'aide de la classe FileWriter :

Classe FileWriter

La classe FileWriter est une autre façon d'écrire dans un fichier en Java. Il s'agit d'une classe de flux de caractères qui vous permet d'écrire des données de caractères dans un fichier. Voici un exemple qui montre comment utiliser la classe FileWriter pour écrire une chaîne dans un fichier :

import java.io.FileWriter;
import java.io.IOException;


// Main method for the string to file in java starts from here,
public class WriteToFileExample {
    public static void main(String[] args) {
        // create a string to write text to file
        String data = "Hello, world!";

        try {
            // create a FileWriter object with the file name
            FileWriter writer = new FileWriter("output.txt");

            // write the string to the file
            writer.write(data);

            // close the writer
            writer.close();

            System.out.println("Successfully wrote text to file.");

        } catch (IOException e) {
            System.out.println("An error occurred.");
            e.printStackTrace();
        }
    }
}

Dans cet exemple, nous créons d’abord un objet String nommé data qui contient le texte que nous voulons écrire dans un fichier. Nous créons ensuite un objet FileWriter avec le nom du fichier dans lequel nous voulons écrire, dans ce cas, nommé output.txt . Ensuite, nous utilisons la méthode write() de l' objet FileWriter pour écrire la chaîne de données dans le fichier. Cette méthode prend un argument String contenant les données à écrire. Enfin, nous fermons l' objet FileWriter pour libérer les ressources du fichier et imprimons un message de réussite sur la console si l'opération d'écriture réussit ou un message d'erreur si une exception est interceptée. La classe FileWriter est un moyen simple d'écrire des données de caractères dans un fichier en Java.

Classe FileOutputStream

La classe FileOutputStream est utilisée pour écrire des données dans un fichier sous forme de flux d'octets. Voici un exemple :

import java.io.FileOutputStream;
import java.io.IOException;

public class WriteToFileExample {
    public static void main(String[] args) {
        String textToWrite = "Hello World!";

        try {
            FileOutputStream stream = new FileOutputStream("output.txt");
            byte[] bytesToWrite = textToWrite.getBytes();
            stream.write(bytesToWrite);
            stream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Dans cet exemple, nous créons un objet FileOutputStream nommé stream avec le nom de fichier "output.txt" dans lequel écrire. Nous convertissons ensuite la chaîne textToWrite en un tableau d'octets à l'aide de la méthode getBytes() et écrivons le tableau d'octets dans l'objet stream à l'aide de la méthode write() . Enfin, nous fermons l' objet stream .

Classe BufferedWriter

La classe BufferedWriter est utilisée pour écrire du texte dans un fichier avec des capacités de mise en mémoire tampon. Voici un exemple :

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class WriteToFileExample {
    public static void main(String[] args) {
        String textToWrite = "Hello World!";

        try {
            BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"));
            writer.write(textToWrite);
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Dans cet exemple, nous créons un objet BufferedWriter nommé écrivain avec un objet FileWriter qui écrit dans le fichier « output.txt ». Nous utilisons ensuite la méthode write() de l’ objet écrivain pour écrire le textToWrite dans le fichier. Enfin, nous fermons l' objet écrivain .

Méthode WriteString()

La méthode writeString() est une méthode pratique introduite dans Java 11 pour écrire une chaîne dans un fichier à l'aide de la classe Files . Il vous permet d'écrire une chaîne dans un fichier en une seule ligne de code. Voici un exemple :

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class WriteToFileExample {
    public static void main(String[] args) {
        // create a string to write to a file
        String data = "Hello, world!";

        // create a file object
        Path file = Paths.get("output.txt");

        try {
            // write the string to the file using writeString() method
            Files.writeString(file, data);

            System.out.println("Successfully wrote text to file.");

        } catch (IOException e) {
            System.out.println("An error occurred.");
            e.printStackTrace();
        }
    }
}

Dans cet exemple, nous créons d’abord un objet String nommé data qui contient le texte que nous voulons écrire dans un fichier. Nous créons ensuite un objet Path nommé file qui représente le fichier dans lequel nous voulons écrire, dans ce cas, nommé "output.txt". Ensuite, nous utilisons la méthode Files.writeString() pour écrire la chaîne de données dans le fichier représenté par l' objet fichier . Cette méthode prend deux arguments : l' objet Path représentant le fichier dans lequel écrire et l' objet String contenant les données à écrire. Enfin, nous imprimons un message de réussite sur la console si l'opération d'écriture réussit ou un message d'erreur si une exception est interceptée. La méthode writeString() est un moyen pratique d'écrire une chaîne dans un fichier à l'aide de Java 11 ou version ultérieure.

Classe PrintWriter

La classe PrintWriter vide automatiquement le tampon de sortie après l'écriture de chaque ligne, garantissant ainsi que les données sont immédiatement écrites dans le fichier. Cela en fait un choix pratique pour écrire de grandes quantités de données texte dans un fichier. Voici un exemple:

import java.io.PrintWriter;
import java.io.FileWriter;
import java.io.IOException;

public class WriteToFileExample {
    public static void main(String[] args) {
        String textToWrite = "Hello World!";

        try {
            PrintWriter writer = new PrintWriter(new FileWriter("output.txt"));
            writer.println(textToWrite);
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Dans cet exemple, nous créons un objet PrintWriter nommé écrivain avec un objet FileWrite qui écrit dans le fichier « output.txt ». Nous utilisons ensuite la méthode println() de l’ objet écrivain pour écrire le textToWrite dans le fichier. Enfin, nous fermons l' objet écrivain .

Classe DataOutputStream

La classe DataOutputStream est utilisée pour écrire des types de données Java primitifs dans un fichier sous forme de flux d'octets. Voici un exemple :

import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class WriteToFileExample {
    public static void main(String[] args) {
        String textToWrite = "Hello World!";
        int numberToWrite = 42;

        try {
            DataOutputStream stream = new DataOutputStream(new FileOutputStream("output.txt"));
            stream.writeUTF(textToWrite);
            stream.writeInt(numberToWrite);
            stream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Dans cet exemple, nous créons un objet DataOutputStream nommé stream , qui écrit dans le fichier "output.txt". Nous utilisons ensuite la méthode writeUTF() de l' objet stream pour écrire la chaîne textToWrite et la méthode writeInt() pour écrire l' entier numberToWrite dans le fichier. Enfin, nous fermons l' objet stream .

Classe FileChannel

La classe FileChannel fournit un moyen d'écrire des données dans un fichier à l'aide d'E/S mappées en mémoire. Voici un exemple :

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class WriteToFileExample {
    public static void main(String[] args) {
        String textToWrite = "Hello World!";

        try {
            File file = new File("output.txt");
            RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw");
            FileChannel channel = randomAccessFile.getChannel();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            buffer.put(textToWrite.getBytes());
            buffer.flip();
            channel.write(buffer);
            randomAccessFile.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Dans cet exemple, nous créons d'abord un objet File nommé file avec le nom de fichier "output.txt" comme paramètre. Nous créons ensuite un objet RandomAccessFile nommé randomAccessFile avec l' objet fichier et le mode "rw" comme paramètres. Nous créons ensuite un objet FileChannel nommé canal , qui est initialisé à l'aide de l'objet randomAccessFile . Nous créons ensuite un objet ByteBuffer nommé buffer d'une capacité de 1024 octets et mettons la chaîne textToWrite comme paramètre. Nous retournons ensuite l' objet tampon pour le préparer à l'écriture et l'écrivons dans l'objet canal à l'aide de la méthode write() . Enfin, nous fermons l' objet randomAccessFile .

Conclusion

En conclusion, écrire dans un fichier à l’aide de Java est une tâche courante dans le développement de logiciels qui peut être effectuée à l’aide de plusieurs classes et méthodes intégrées. Dans cet article, nous avons discuté de plusieurs exemples sur la façon d'écrire dans un fichier, notamment l'utilisation des classes FileOutputStream , BufferedWriter , FileWriter , PrintWriter , DataOutputStream et FileChannel . Il est important de noter que lors de l'écriture dans un fichier, une gestion appropriée des erreurs et la fermeture du fichier après l'écriture sont cruciales pour garantir que le fichier est correctement enregistré et que les ressources sont correctement libérées. Grâce aux exemples fournis dans cet article, les débutants peuvent désormais avoir une compréhension de base de la façon d'écrire dans un fichier à l'aide de Java et peuvent commencer à pratiquer et à expérimenter différents cas d'utilisation.