Java >> Tutoriel Java >  >> Tag >> String

Java Écrire dans un fichier | Chaînes de texte | Différentes façons d'écrire des exemples de fichiers

De nombreuses applications d'entreprise doivent écrire du contenu dans le fichier. Par exemple, créer un rapport ou des fichiers de facturation. Le problème est de savoir comment vous allez faire avec Java Write to File ? Il existe de nombreuses façons de le faire. Dans ce didacticiel, nous discuterons de différentes manières d'écrire en Java dans un fichier avec des exemples.

Écrire un fichier en Java

Voici différentes manières d'écrire un fichier en Java.

  • BufferedWritter
  • FileWriter – Écrit directement dans le fichier
  • PrintWriter – Écrire du texte formaté.
  • FileOutputStream – Écrire des données binaires.
  • DataOutputStream – Écrire des types de données primitifs
  • FileChannel – Écrire des fichiers plus volumineux
  • Écrire un fichier à l'aide du chemin Java 7

Démarrons l'exemple Java Write to File de différentes manières

Nous allons examiner une manière rapide et très simple avec de brefs détails sur la façon d'écrire des fichiers. Si nous avons essayé un fichier d'écriture et que ce fichier n'existe pas, il générera une erreur, utilisez donc toujours le bloc try-catch ou utilisez la gestion des exceptions. La plupart des exemples sont basés sur Java écrire une chaîne dans un fichier.

BufferedWritter

Le plus simple pour écrire un fichier en Java utilisait BufferedWritter, qui écrit du texte dans un flux de sortie de caractères. Il est donc plus efficace d'écrire des caractères, des chaînes et des tableaux uniques.

Voir l'exemple ci-dessous. Vous aviez besoin d'un code écrit dans la gestion des exceptions try-catch car il y a beaucoup de risques d'erreur. Comme erreur de fichier introuvable, etc.

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

public class FileWriting {
    public static void main(String arg[]) {

        String fileContent = "Hello BufferedWriter file writing ";

        try {
            BufferedWriter writer =
                    new BufferedWriter(new FileWriter("samplefile.txt"));

            writer.write(fileContent);
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Voici une présentation gif du fichier projet et de la sortie du code.

Écrire un fichier Java à l'aide de FileWriter/PrintWriter

FileWriter écrit directement dans le fichier. Ses performances sont inférieures à celles des autres, utilisez-les donc uniquement lorsque vous souhaitez une écriture en moins. Sa syntaxe est propre et simple, voir l'exemple ci-dessous. Cela supprimera l'ancien contenu du fichier, le cas échéant.

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

public class FileWriting {
    public static void main(String arg[]) {

        String fileContent = "Hello FileWriter ";

        try {
            FileWriter fileWriter = new FileWriter("samplefile.txt");
            fileWriter.write(fileContent);
            fileWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

PrintWriter est utilisé lorsque vous souhaitez écrire un fichier au format. Elle présente certains avantages car cette classe implémente toutes les méthodes d'impression trouvées dans PrintStream vous pouvez donc utiliser tous les formats. Et vous pouvez également l'utiliser avec System.out.println() déclarations.

Voir le code, vous aurez une idée de la façon dont printf les autres méthodes peuvent utiliser ici.

public class FileWriting {
    public static void main(String arg[]) {

        String fileContent = "Hello PrintWriter ";

        try {
            FileWriter fileWriter = new FileWriter("samplefile.txt");
            PrintWriter printWriter = new PrintWriter(fileWriter);
            printWriter.print(fileContent);
            printWriter.printf("writing another string");
            printWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileOutputStream

Avec FileOutputStream, vous pouvez écrire des données binaires dans un fichier. Pour un exemple d'écriture de données de ligne d'image.

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

public class FileWriting {
    public static void main(String arg[]) {

        String fileContent = "Hello FileOutputStream ";

        try {
            FileOutputStream outputStream = new FileOutputStream("samplefile.txt");
            byte[] strToBytes = fileContent.getBytes();
            outputStream.write(strToBytes);

            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

DataOutputStream

Lorsque vous souhaitez écrire des types de données Java primitifs, DataOutputStream est un moyen portable. Relecture possible des données d'un fichier.

import java.io.*;


public class FileWriting {
    public static void main(String arg[]) {

        String fileContent = "Hello FileOutputStream";

        try {
            FileOutputStream outputStream = new FileOutputStream("c:/temp/samplefile5.txt");
            DataOutputStream dataOutStream = new DataOutputStream(new BufferedOutputStream(outputStream));
            dataOutStream.writeUTF(fileContent);

            dataOutStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileChannel

Lorsque vous souhaitez écrire un fichier plus volumineux, utilisez FileChannel. Il est utilisé pour lire, écrire, mapper et manipuler un fichier. C'est plus rapide que les E/S standard dans les cas de fichiers plus volumineux.

Le canal de fichiers est également sécurisé sur plusieurs threads simultanés. Voir exemple pour cela.

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

public class FileWriting {
    public static void main(String arg[]) {

        String fileContent = "Hello File channel";

        try {
            RandomAccessFile stream = new RandomAccessFile("samplefile.txt", "rw");
            FileChannel channel = stream.getChannel();
            byte[] strBytes = fileContent.getBytes();
            ByteBuffer buffer = ByteBuffer.allocate(strBytes.length);
            buffer.put(strBytes);
            buffer.flip();
            channel.write(buffer);
            stream.close();
            channel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Utilisation du chemin Java 7

Java 7 a introduit la classe utilitaire Files dans laquelle vous pouvez écrire un fichier à l'aide de sa méthode d'écriture , en interne, il utilise OutputStream pour écrire un tableau d'octets dans un fichier.

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

public class FileWriting {
    public static void main(String arg[]) {

        String fileContent = "Hello Java 7 Path";

        try {
            Path path = Paths.get("samplefile.txt");
            Files.write(path, fileContent.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

API dans Java 8 Écrire dans un fichier

Où BufferedWriter est utilisé pour écrire du texte dans un flux de caractères ou d'octets. Il stocke un caractère dans le tampon, puis l'imprime par groupes.

Voici un exemple de programme Java pour écrire du contenu dans un fichier à l'aide des API Java 8.

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

public class FileWriting {
    public static void main(String arg[]) {

        Path path = Paths.get("samplefile.txt");

        try (BufferedWriter writer = Files.newBufferedWriter(path)) {
            writer.write("Hello World !!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Question :Java écrit dans le fichier ligne par ligne ?

Répondre  :Différentes manières ont différentes méthodes, nous en partageons ici quelques-unes.

FileOutputStream

bufferWriter.write("new line");
bufferWriter.newLine();

FileWriter

fileWriter.write("new line");

PrintWriter

printWriter.write("New line");

OutputStreamWriter

osw.write("New line");

Quelques points importants lors de l'écriture java dans un fichier :

  • Utilisez try-catch ou la gestion des exceptions pour éviter le plantage de l'application
  • Fermez le flux de sortie après utilisation pour libérer toutes les ressources.

Balise Java