In Java in eine Datei schreiben: Beste Möglichkeiten und andere Ansätze zum Schreiben

  In Java in eine Datei schreiben

Beste Möglichkeiten zum Schreiben in eine Datei in Java

Für Programmierer, die in Java schreiben und einen Java-Schreibvorgang in eine Datei durchführen müssen, gibt es vier Hauptmethoden, um dies zu erreichen: FileWriter, BufferedWriter, Java 7 Files und FileOutput Stream. Auf all das gehen wir heute ein.

Hier ist ein kurzer Überblick, auf den wir im weiteren Verlauf näher eingehen:

Schnelle Navigation
Beste Möglichkeiten zum Schreiben in eine Datei in JavaFileWriterBufferedWriterFileOutputStreamDateienAndere Ansätze zum Schreiben in eine DateiEingabeströme BufferedWriter PrintWriter Vergessen Sie nicht, wann Sie einen Java-Write-to-File durchführen

FileWriter

Da es die einfachste Möglichkeit ist, eine Datei in Java zu schreiben, ist FileWriter eine der beliebtesten Methoden. Dank der überladenen Schreibmethode kann der Programmierer String in die Datei schreiben und ein Byte-Array schreiben. FileWriter ermöglicht auch das Schreiben eines Teils des String- oder Byte-Arrays. Da FileWriter direkt in Dateien schreibt, sollte es verwendet werden, wenn die Anzahl der Schreibvorgänge geringer ist.

BufferedWriter

BufferedWriter hat viele Ähnlichkeiten mit FileWriter, mit Ausnahme eines internen Puffers zum Schreiben von Daten in File. Wenn die tatsächliche Anzahl der Schreibvorgänge größer ist, sind die E/A-Vorgänge geringer und die Leistung erhöht. Dies macht BufferedWriter zu einer besseren Wahl, wenn eine große Anzahl von Schreibvorgängen ausgeführt werden muss.

FileOutputStream

Wenn viele rohe Stream-Daten in eine Datei geschrieben werden müssen, ist FileOutputStream eine gute Wahl. FileWriter und BufferedWriter eignen sich hervorragend zum Schreiben von Text in eine Datei, aber FileOutputStream ist für diese Anwendungen sicherlich besser.

Dateien

Java 7 war das Debüt der Files-Dienstprogrammklasse und ihr OutputStream ist darauf ausgelegt, Byte-Arrays in eine Datei zu schreiben.

Beispiel für Java Write to File (mit freundlicher Genehmigung von journalistdev.com)

Hier ist ein Beispiel für eine Standardmethode zum Schreiben in eine Datei in Java:

Paket com.journaldev.files;

import java.io.BufferedWriter;

java.io.File importieren;

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;

öffentliche Klasse WriteFile {

/**

* Dieser Kurs zeigt, wie man eine Datei in Java schreibt

* @param args

* @throws IOException

*/

public static void main(String[] args) {

String data = „Ich werde diesen String in Java in eine Datei schreiben“;

int noOfLines = 10000;

writeUsingFileWriter(data);

writeUsingBufferedWriter(data, noOfLines);

writeUsingFiles(data);

writeUsingOutputStream(data);

System.out.println(„FERTIG“);

}

/**

* Verwenden Sie Streams, wenn Sie mit Rohdaten arbeiten

* @param-Daten

*/

private static void writeUsingOutputStream(String data) {

OutputStream os = null;

versuchen {

os = new FileOutputStream(new File(„/Users/pankaj/os.txt“));

os.write(data.getBytes(), 0, data.length());

} Catch (IOException e) {

e.printStackTrace();

}Endlich{

versuchen {

os.close();

} Catch (IOException e) {

e.printStackTrace();

}

}

}

/**

* Verwenden Sie die Files-Klasse von Java 1.7 zum Schreiben von Dateien, intern wird OutputStream verwendet

* @param-Daten

*/

private static void writeUsingFiles(String data) {

versuchen {

Files.write(Paths.get(„/Users/pankaj/files.txt“), data.getBytes());

} Catch (IOException e) {

e.printStackTrace();

}

}

/**

* Verwenden Sie BufferedWriter, wenn die Anzahl der Schreibvorgänge höher ist

* Es verwendet einen internen Puffer, um echte E/A-Vorgänge zu reduzieren und Zeit zu sparen

* @param-Daten

* @param noOfLines

*/

private static void writeUsingBufferedWriter(String data, int noOfLines) {

Datei file = new File(„/Users/pankaj/BufferedWriter.txt“);

FileWriter fr = null;

BufferedWriter br = null;

String dataWithNewLine=data+System.getProperty(„line.separator“);

versuchen{

fr = neuer FileWriter(Datei);

br = neuer BufferedWriter(fr);

for(int i = noOfLines; i>0; i–){

br.write(dataWithNewLine);

}

} Catch (IOException e) {

e.printStackTrace();

}Endlich{

versuchen {

br.close();

fr.close();

} Catch (IOException e) {

e.printStackTrace();

}

}

}

/**

* Verwenden Sie FileWriter, wenn die Anzahl der Schreibvorgänge geringer ist

* @param-Daten

*/

private static void writeUsingFileWriter(String data) {

Datei file = new File(„/Users/pankaj/FileWriter.txt“);

FileWriter fr = null;

versuchen {

fr = neuer FileWriter(Datei);

fr.write(data);

} Catch (IOException e) {

e.printStackTrace();

}Endlich{

//Ressourcen schließen

versuchen {

fr.close();

} Catch (IOException e) {

e.printStackTrace();

}

}

}

}

Andere Ansätze zum Schreiben in eine Datei

Es gibt tatsächlich eine Vielzahl von Methoden zum Schreiben in eine Datei, wenn es um Java geht. Jede hat ihre Vor- und Nachteile, und die Vielfalt der Methoden kann ziemlich verwirrend sein.

Eingabeströme

Schreiben Eingabeströme ist die einfachste und direkteste Möglichkeit, Daten in Dateien für Java zu schreiben.

Hier ist ein Beispiel, mit freundlicher Genehmigung von octoperf.com:

Paket com.octoperf;

importieren com.google.common.io.Closer;

importieren org.junit.Rule;

importieren org.junit.Test;

importieren org.junit.rules.TemporaryFolder;

importieren java.io.BufferedOutputStream;

importieren java.io.BufferedWriter;

importieren java.io.File;

importieren java.io.FileOutputStream;

importieren java.io.FileWriter;

importieren java.io.IOException;

importieren java.io.PrintWriter;

importieren java.io.Writer;

importieren
statisch com.google.common.base.Charsets.UTF_8;

öffentlich
Klasse
JavaWriteFileTest {

Privat
statisch
Finale String HELLO_WORLD = „Hallo Welt!“;

Privat
statisch
Finale String OUT_TXT = „out.txt“;

@Regel

öffentlich TemporaryFolder-Ordner = neu Temporärer Ordner();

@Prüfen

öffentlich
Leere
inputOutputTryFinally() wirft IOException {

Finale Datei file = Ordner.newFile(OUT_TXT);

BufferedOutputStream out = Null;

versuchen {

aus = neu BufferedOutputStream(neu FileOutputStream(file));

out.write(HELLO_WORLD.getBytes(UTF_8));

} Endlich {

Wenn (aus != Null) {

out.close();

}

}

}

@Prüfen

öffentlich
Leere
inputOutputCloser() wirft IOException {

Finale Datei file = Ordner.newFile(OUT_TXT);

Finale Näher näher = Closer.create();

versuchen {

Finale BufferedOutputStream out = close.register(neu BufferedOutputStream(neu FileOutputStream(file)));

out.write(HELLO_WORLD.getBytes(UTF_8));

} Endlich {

näher.close();

}

}

@Prüfen

öffentlich
Leere
inputOutputTryResources() wirft IOException {

Finale Datei file = Ordner.newFile(OUT_TXT);

versuchen (Finale BufferedOutputStream out = neu BufferedOutputStream(neu FileOutputStream(file))) {

out.write(HELLO_WORLD.getBytes(UTF_8));

}

}

}

Hier haben wir BufferedOutputStream und FileOutputStream verwendet, um das klassische Beispiel von Hello World! zu schreiben. In die Datei. Es ist jedoch nicht ratsam, es so zu formulieren:

Out.write(HELLO_WORLD.getBytes() );

In einem solchen Fall konvertiert die Standardcodierung der Plattform die Zeichenfolge in Bytes. Dies ist in Ordnung, kann jedoch zu Problemen führen, wenn sich die Codierung ändert. Um die Zeichenfolge in Bytes umzuwandeln, lautet der Code:

HELLO_WORLD.getBytes(UTF_8)

würde ins Spiel kommen, aber das ist keine sehr elegante Lösung. Ein DataOutputStream kann dies verbessern und rationalisieren:

@Prüfen

öffentlich
Leere
dataOutputTryFinally() wirft IOException {

Finale Datei file = Ordner.newFile(OUT_TXT);

DataOutputStream out = Null;

versuchen {

aus = neu DataOutputStream(neu BufferedOutputStream(neu FileOutputStream(file)));

out.writeUTF(HELLO_WORLD);

} Endlich {

Wenn (aus != Null) {

out.close();

}

}

An diesem Punkt ist der Code out.writeUTF(HELLO_WORLD); kann verwendet werden, um den String direkt in UTF-kodierte Bytes zu schreiben.

BufferedWriter

BufferedWriter Puffert Zeichen für ein effizienteres Schreiben von Zeichenfolgen, Arrays und einzelnen Zeichen als Zeichenausgabestream. Während der Standardwert für die meisten Anwendungen groß genug ist, kann die Puffergröße angegeben werden. In den meisten Fällen kann ein Writer die Ausgabe direkt an den Bytestream oder das zugrunde liegende Zeichen senden. In den meisten Fällen kann ein BufferedWriter in Fällen, in denen Schreibvorgänge kostspielig sein können, um jeden Writer gewickelt werden, z. B. beim Schreiben in eine Datei in Java mit OutputStreamWriters oder FileWriters.

Hier ist ein Beispiel:

@Prüfen

öffentlich
Leere
dataOutputTryFinally() wirft IOException {

Finale Datei file = Ordner.newFile(OUT_TXT);

DataOutputStream out = Null;

versuchen {

aus = neu DataOutputStream(neu BufferedOutputStream(neu FileOutputStream(file)));

out.writeUTF(HELLO_WORLD);

} Endlich {

Wenn (aus != Null) {

out.close();

}

}

Dies veranschaulicht drei verschiedene Möglichkeiten, BufferedWriter zu verwenden. Das try…finally-Muster kommt ins Spiel, um sicherzustellen, dass der Writer geschlossen ist, auch wenn während des Schreibvorgangs eine Ausnahme auftritt. bufferedWriterCloser schließt den Writer mit einer final-Klausel und bufferedWriter TryResources verwendet die mit Java7 entwickelte „Try with resources“-Syntax.

Die Syntax unterscheidet sich geringfügig, je nachdem, wie Sie den Writer schließen möchten, das Ergebnis ist jedoch trotzdem dasselbe. In all diesen Fällen würde der ursprüngliche Dateiinhalt überschrieben werden. Hier ist ein Beispiel dafür, wie Sie damit umgehen, wenn Sie die Datei nur anhängen möchten:

@Prüfen

öffentlich
Leere
bufferedWriterTryResourcesAppend() wirft IOException {

Finale Datei file = Ordner.newFile(OUT_TXT);

versuchen (Finale Schriftsteller Schriftsteller = neu BufferedWriter(neu FileWriter(Datei, WAHR))) {

Writer.write(HELLO_WORLD);

}

}

Ist Ihnen in diesem Beispiel das „wahre“ zweite Argument aufgefallen, das FileWriter hinzugefügt wurde? Es hat die gleiche Funktion wie append=true. Am Ende wird die geschriebene Datei die Zeichenfolge „Hello World!“ enthalten.

PrintWriter

Hier werden wir etwas über PrintWriter erfahren, der einige nette Funktionen enthält, die den Standard-BufferedWriter verbessern:

Paket com.octoperf;

importieren com.google.common.io.Closer;

importieren org.junit.Rule;

importieren org.junit.Test;

importieren org.junit.rules.TemporaryFolder;

importieren java.io.BufferedWriter;

importieren java.io.File;

importieren java.io.FileWriter;

importieren java.io.IOException;

importieren java.io.PrintWriter;

importieren java.io.Writer;

öffentlich
Klasse
JavaWriteFileTest {

Privat
statisch
Finale String HELLO_WORLD = „Hallo Welt!“;

Privat
statisch
Finale String OUT_TXT = „out.txt“;

@Regel

öffentlich TemporaryFolder-Ordner = neu Temporärer Ordner();

@Prüfen

öffentlich
Leere
printWriterTryFinally() wirft IOException {

Finale Datei file = Ordner.newFile(OUT_TXT);

PrintWriter-Writer = Null;

versuchen {

Schriftsteller = neu PrintWriter(neu FileWriter(Datei));

write.printf(„Hallo %s!“, „John Smith“);

} Endlich {

Wenn (Autor != Null) {

Writer.close();

}

}

}

@Prüfen

öffentlich
Leere
printWriterCloser() wirft IOException {

Finale Datei file = Ordner.newFile(OUT_TXT);

Finale Näher näher = Closer.create();

versuchen {

Finale PrintWriterwriter = close.register(neu PrintWriter(neu FileWriter(Datei)));

write.printf(„Hallo %s!“, „John Smith“);

} Endlich {

näher.close();

}

}

@Prüfen

öffentlich
Leere
printWriterTryResources() wirft IOException {

Finale Datei file = Ordner.newFile(OUT_TXT);

versuchen (PrintWriter-Writer = neu PrintWriter(neu FileWriter(Datei))){

write.printf(„Hallo %s!“, „John Smith“);

}

}

}

Beachten Sie, dass wir erneut drei Abschlussmethoden verwendet haben und immer noch zum gleichen Ergebnis kamen. Um eine formatierte Zeichenfolge zu schreiben, write.printf („Hello %s!“, „John Smith“); ist ein bequemer Ansatz. Diese Zeichenfolge enthält „John Smith“ in der Datei.

Vergessen Sie nicht, wann Sie einen Java-Write-to-File durchführen

Vergessen Sie beim Lesen oder Schreiben von Inhalten aus einer Datei nicht, alle zugehörigen Ressourcen zu schließen.

Wenn Dinge nicht ordnungsgemäß geschlossen werden, bleibt ein Zeiger auf die Datei geöffnet, was zu Verhaltensweisen wie dem Erreichen des Limits für offene Dateien oder einfach dazu führt, dass eine Datei nicht geschrieben werden kann, weil sie als bereits geöffnet gilt.

Viel Glück!

Kommentar verfassen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Nach oben scrollen