[Java] Que dois-je utiliser pour écrire des fichiers?

Contexte

Il existe de nombreuses classes pour lire et écrire des fichiers, mais je ne savais pas quelle classe était la meilleure à utiliser. Autrefois, je faisais référence au code d'un autre projet ~~ copy ~~. Alors j'ai cherché. En conclusion, plus je levais les yeux, plus j'étais confus. Et utilisez ceci! !! Je n'ai rien trouvé de tel.

Qu'est-ce que Stream?

Traitez les données en octets. ~~ Au fait, il n'y a pas de classe appelée Stream. ~~ interface https://docs.oracle.com/javase/jp/8/docs/api/java/util/stream/Stream.html

InputStream Une classe qui fait ** "lire" ** avec des octets.

OutputStream Une classe qui ** "écrit" ** avec des octets.

FileInputStream Une classe pour lire des octets. Une classe enfant de InputStream. C'est assez vieux.

FileOutputStream Une classe pour écrire des octets. Une classe enfant de OutputStream. C'est assez vieux.

InputStreamReader Le rôle de transmettre le InputStream au lecteur. Spécifiez le code de caractère ici.

OutputStreamWriter Le rôle de transmettre le flux de sortie à l'enregistreur. Spécifiez le code de caractère ici.

Reader Faites ** "lire" ** à partir du flux en unités de caractères (char [] dans le code) au lieu d'octets.

Writer Faites ** "écrire" ** à partir du flux en unités de caractères (char [] dans le code) au lieu d'octets.

Qu'est-ce que la mise en mémoire tampon?

Une fonction qui stocke en mémoire et lit et écrit à la fois lorsqu'un certain montant est accumulé. En conséquence, les performances de lecture et d'écriture octet par octet sont bonnes.

BufferedReader Avec la fonction de mise en mémoire tampon du lecteur

BufferedWriter Avec la fonction de mise en mémoire tampon Writer

J'ai essayé d'implémenter la fonction d'écriture de fichier

import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class FileCreate {
    public static void main(String[] args) {

        //Chemin du fichier à lire et à écrire
        Path path = Paths.get("C:\\demo.txt");
        //Chaîne de caractères à écrire
        List<String> lines = Stream.of("AIUEO", "Kakikukeko", "SA Shi Su Se So").collect(Collectors.toList());

        //Écriture de fichier 1
        //Le code de caractère est UTF par défaut-8
        //J'utilise OutputStreamWriter
        try (BufferedWriter writer = Files.newBufferedWriter(path)) {
            for (String str : lines) {
                //Notez que si vous passez null, il sera écrit sous la forme d'une chaîne de caractères appelée null.
                writer.append(str);
                writer.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        //Écriture de fichier 2
        //Utilise en interne BufferedWriter, OutputWriter et FileOutputStream
        try {
            //Lorsque vous voulez en écrire un nouveau
            Files.write(path, lines, Charset.forName("Shift_JIS"), StandardOpenOption.WRITE);
            //Lorsque vous souhaitez ajouter
            Files.write(path, lines, Charset.forName("Shift_JIS"), StandardOpenOption.APPEND);
        } catch (IOException e) {
            e.printStackTrace();
        }

        //Écriture de fichier 3
        // printWriter
        try (
            //Vrai si vous voulez ajouter, faux si nouveau
            FileOutputStream fileOutputStream = new FileOutputStream(path.toFile(), true);
            OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, Charset.forName("Shift_JIS"));
            PrintWriter printWriter = new PrintWriter(outputStreamWriter)) {

            for (String s : lines) {
                printWriter.println(s);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        //Écriture de fichier 4
        // BufferedWriter
        try (
            //Vrai si vous voulez ajouter, faux si nouveau
            FileOutputStream fileOutputStream = new FileOutputStream(path.toFile(), true);
            OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, Charset.forName("Shift_JIS"));
            BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter)) {

            for (String s : lines) {
                bufferedWriter.append(s);
                bufferedWriter.newLine();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Si vous voulez garder les choses simples, je pense que vous pouvez écrire le fichier 1 ou 2. Cependant, si vous souhaitez personnaliser le contenu d'écriture à votre guise, j'utiliserai l'écriture de fichier 3 ou 4.

L'écriture de fichier 3 et 4 est facile à comprendre et à déclarer les variables une par une. Bien sûr, il est normal de les rassembler en une seule ligne.

new BufferedWriter(new OutputStreamWriter(new FileOutputStream(path.toFile(), true), Charset.forName("Shift_JIS")));

Une chose à garder à l'esprit est de ne pas oublier close ().

À la fin

J'ai passé environ deux jours à faire des recherches, mais je pouvais à peu près le comprendre. Cependant, je sens que je ne comprends pas les détails. Si c'est faux, ou ce code est-il inutile? Je vous serais reconnaissant si vous pouviez souligner certains points.