[Java] Was soll ich zum Schreiben von Dateien verwenden?

Hintergrund

Es gibt viele Klassen zum Lesen und Schreiben von Dateien, aber ich wusste nicht, welche Klasse am besten zu verwenden ist. Früher habe ich mich auf den Code eines anderen Projekts bezogen ~~ copy ~~. Also habe ich nachgeschlagen. Je mehr ich aufblickte, desto verwirrter war ich. Und benutze das! !! Ich habe so etwas nicht gefunden.

Was ist Stream?

Daten in Bytes verarbeiten. ~~ Übrigens gibt es keine Klasse namens Stream. ~~ Schnittstelle https://docs.oracle.com/javase/jp/8/docs/api/java/util/stream/Stream.html

InputStream Eine Klasse, die mit Bytes ** "liest" **.

OutputStream Eine Klasse, die mit Bytes ** "schreibt" **.

FileInputStream Eine Klasse zum Lesen von Bytes. Eine untergeordnete Klasse von InputStream. Es ist ziemlich alt.

FileOutputStream Eine Klasse zum Schreiben von Bytes. Eine untergeordnete Klasse von OutputStream. Es ist ziemlich alt.

InputStreamReader Die Rolle der Übergabe des InputStream an den Reader. Geben Sie hier den Zeichencode an.

OutputStreamWriter Die Rolle der Übergabe des Ausgabestreams an den Writer. Geben Sie hier den Zeichencode an.

Reader Führen Sie ** "Lesen" ** aus dem Stream in Zeicheneinheiten (char [] im Code) anstelle von Bytes durch.

Writer ** "schreibe" ** aus dem Stream in Zeicheneinheiten (char [] im Code) anstelle von Bytes.

Was ist Pufferung?

Eine Funktion, die im Speicher gespeichert und sofort gelesen und geschrieben wird, wenn ein bestimmter Betrag akkumuliert wird. Infolgedessen ist die Leistung beim Lesen und Schreiben von Byte für Byte gut.

BufferedReader Mit Reader-Pufferfunktion

BufferedWriter Mit Writer-Pufferfunktion

Ich habe versucht, die Dateischreibfunktion zu implementieren

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

        //Dateipfad zum Lesen und Schreiben
        Path path = Paths.get("C:\\demo.txt");
        //Zu schreibende Zeichenkette
        List<String> lines = Stream.of("AIUEO", "Kakikukeko", "SA Shi Su Se So.").collect(Collectors.toList());

        //Datei schreiben 1
        //Der Zeichencode ist standardmäßig UTF-8
        //Ich benutze OutputStreamWriter
        try (BufferedWriter writer = Files.newBufferedWriter(path)) {
            for (String str : lines) {
                //Beachten Sie, dass wenn Sie null übergeben, es als Zeichenfolge mit dem Namen null geschrieben wird.
                writer.append(str);
                writer.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        //Datei schreiben 2
        //Verwendet intern BufferedWriter, OutputWriter und FileOutputStream
        try {
            //Wenn Sie einen neuen schreiben möchten
            Files.write(path, lines, Charset.forName("Shift_JIS"), StandardOpenOption.WRITE);
            //Wenn Sie hinzufügen möchten
            Files.write(path, lines, Charset.forName("Shift_JIS"), StandardOpenOption.APPEND);
        } catch (IOException e) {
            e.printStackTrace();
        }

        //Datei schreiben 3
        // printWriter
        try (
            //True, wenn Sie hinzufügen möchten, false, wenn neu
            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();
        }

        //Datei schreiben 4
        // BufferedWriter
        try (
            //True, wenn Sie hinzufügen möchten, false, wenn neu
            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();
        }
    }
}

Wenn Sie die Dinge einfach halten möchten, können Sie meiner Meinung nach Datei 1 oder 2 schreiben. Wenn Sie jedoch den Schreibinhalt nach Ihren Wünschen anpassen möchten, verwende ich das Schreiben von Dateien 3 oder 4.

Das Schreiben von Dateien 3 und 4 ist für Sie leicht zu verstehen und Variablen einzeln zu deklarieren. Natürlich ist es in Ordnung, sie in einer Zeile zusammenzufassen.

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

Eine Sache, die Sie beachten sollten, ist, dass Sie close () nicht vergessen.

Am Ende

Ich habe ungefähr zwei Tage damit verbracht, es zu erforschen, aber ich konnte es grob verstehen. Ich habe jedoch das Gefühl, dass ich die Details nicht verstehe. Wenn es falsch ist oder ist dieser Code nutzlos? Ich würde mich freuen, wenn Sie auf Punkte hinweisen könnten.