Wie erstelle ich eine Datei und schreibe sie in Java?

1383

Was ist der einfachste Weg, um eine (Text-) Datei in Java zu erstellen und in diese zu schreiben?

Drew Johnson
quelle

Antworten:

1735

Beachten Sie, dass jedes der folgenden Codebeispiele möglicherweise ausgelöst wird IOException. Try / catch / finally-Blöcke wurden der Kürze halber weggelassen. Informationen zur Ausnahmebehandlung finden Sie in diesem Lernprogramm .

Beachten Sie, dass jedes der folgenden Codebeispiele die Datei überschreibt, wenn sie bereits vorhanden ist

Erstellen einer Textdatei:

PrintWriter writer = new PrintWriter("the-file-name.txt", "UTF-8");
writer.println("The first line");
writer.println("The second line");
writer.close();

Erstellen einer Binärdatei:

byte data[] = ...
FileOutputStream out = new FileOutputStream("the-file-name");
out.write(data);
out.close();

Benutzer von Java 7+ können die FilesKlasse zum Schreiben in Dateien verwenden:

Erstellen einer Textdatei:

List<String> lines = Arrays.asList("The first line", "The second line");
Path file = Paths.get("the-file-name.txt");
Files.write(file, lines, StandardCharsets.UTF_8);
//Files.write(file, lines, StandardCharsets.UTF_8, StandardOpenOption.APPEND);

Erstellen einer Binärdatei:

byte data[] = ...
Path file = Paths.get("the-file-name");
Files.write(file, data);
//Files.write(file, data, StandardOpenOption.APPEND);
Michael
quelle
58
Bemerkenswert ist, dass PrintWriter die Dateigröße auf Null abschneidet, wenn die Datei bereits vorhanden ist
Covar
34
PrintWriter kann (und wird oft) verwendet werden, ist jedoch (konzeptionell) nicht die richtige Klasse für den Job. Aus den Dokumenten: "PrintWriter prints formatted representations of objects to a text-output stream. "Bozhos Antwort ist korrekter, obwohl sie umständlich aussieht (Sie können sie jederzeit in eine Dienstprogrammmethode einschließen).
Leonbloy
14
Wo wird die Textdatei erstellt, nachdem die App erstellt und auf einem anderen PC verwendet wurde, da wir den Pfad nicht angegeben haben?
Marlon Abeykoon
13
@ MarlonAbeykoon Gute Frage. Die Antwort ist, dass die Textdatei im Arbeitsverzeichnis erstellt wird . Das Arbeitsverzeichnis ist das Verzeichnis, aus dem Sie Ihr Programm ausführen. Wenn Sie beispielsweise Ihr Programm über die Befehlszeile ausführen, ist das Arbeitsverzeichnis das Verzeichnis, in dem Sie sich gerade befinden (unter Linux geben Sie "pwd" ein, um das aktuelle Arbeitsverzeichnis anzuzeigen). Wenn ich auf eine JAR-Datei auf meinem Desktop doppelklicke, um sie auszuführen, ist das Arbeitsverzeichnis der Desktop.
Michael
8
writer.close()sollte in einem endgültigen Block sein
Thierry
416

In Java 7 und höher:

try (Writer writer = new BufferedWriter(new OutputStreamWriter(
              new FileOutputStream("filename.txt"), "utf-8"))) {
   writer.write("something");
}

Dafür gibt es jedoch nützliche Dienstprogramme:

Beachten Sie, dass auch Sie können verwenden ein FileWriter, aber es nutzt die Standard - Kodierung, die oft eine schlechte Idee - es ist am besten , die Codierung explizit angeben.

Unten finden Sie die ursprüngliche Antwort vor Java 7


Writer writer = null;

try {
    writer = new BufferedWriter(new OutputStreamWriter(
          new FileOutputStream("filename.txt"), "utf-8"));
    writer.write("Something");
} catch (IOException ex) {
    // Report
} finally {
   try {writer.close();} catch (Exception ex) {/*ignore*/}
}

Siehe auch: Lesen, Schreiben und Erstellen von Dateien (einschließlich NIO2).

Bozho
quelle
5
@leonbloy Ich weiß, dass dies ein alter Kommentar ist, aber wenn jemand dies sieht, würde es Ihnen etwas ausmachen zu erklären, warum dies nicht "immer von Vorteil" ist? Zumindest hier steht "top effizient" docs.oracle.com/javase/1.5.0/docs/api/java/io/…
Juan
14
Es sieht so aus, als hätte der Writer keine writeln () -Methode. Es hat nur schreiben ()
YankeeWhiskey
10
Wenn Sie den Typ des Schreibers in BufferedWriter ändern (was es tatsächlich ist), können Sie writer.newLine ()
Niek
4
Es scheint nicht richtig zu sein, endlich einen Versuch / Fang in einem zu haben. Ich kenne den Grund dafür, aber es scheint wie ein Codegeruch.
Asche999
4
@Trengot Es tut. Wenn Sie close()einen Stream aufrufen, der um einen anderen gewickelt ist, werden auch alle inneren Streams geschlossen.
Fund Monica Klage
132

Wenn Sie bereits über den Inhalt verfügen, den Sie in die Datei schreiben möchten (und der nicht im laufenden Betrieb generiert wird), bietet das java.nio.file.FilesHinzufügen in Java 7 als Teil der nativen E / A die einfachste und effizienteste Möglichkeit, Ihre Ziele zu erreichen.

Grundsätzlich ist das Erstellen und Schreiben in eine Datei nur eine Zeile, außerdem ein einfacher Methodenaufruf !

Im folgenden Beispiel werden 6 verschiedene Dateien erstellt und in diese geschrieben, um zu zeigen, wie sie verwendet werden können:

Charset utf8 = StandardCharsets.UTF_8;
List<String> lines = Arrays.asList("1st line", "2nd line");
byte[] data = {1, 2, 3, 4, 5};

try {
    Files.write(Paths.get("file1.bin"), data);
    Files.write(Paths.get("file2.bin"), data,
            StandardOpenOption.CREATE, StandardOpenOption.APPEND);
    Files.write(Paths.get("file3.txt"), "content".getBytes());
    Files.write(Paths.get("file4.txt"), "content".getBytes(utf8));
    Files.write(Paths.get("file5.txt"), lines, utf8);
    Files.write(Paths.get("file6.txt"), lines, utf8,
            StandardOpenOption.CREATE, StandardOpenOption.APPEND);
} catch (IOException e) {
    e.printStackTrace();
}
icza
quelle
Schön gemacht. Ich mag das Beispiel file5 und file6. Um Datei6 zu testen, stellen Sie sicher, dass Sie das Programm zweimal ausführen. Dann werden die Zeilen erneut angehängt.
Tazboy
76
public class Program {
    public static void main(String[] args) {
        String text = "Hello world";
        BufferedWriter output = null;
        try {
            File file = new File("example.txt");
            output = new BufferedWriter(new FileWriter(file));
            output.write(text);
        } catch ( IOException e ) {
            e.printStackTrace();
        } finally {
          if ( output != null ) {
            output.close();
          }
        }
    }
}
Eric Petroelje
quelle
18
Wäre es nicht besser, output.close () in einen finally-Block zu setzen?
Qed
7
Bloßer Code kann hier niemals eine Antwort darstellen. Du musst es erklären.
Marquis von Lorne
7
Eigentlich wird dies nicht kompiliert, output.close()wirft IOException
Bob Yoplait
43

Hier ist ein kleines Beispielprogramm zum Erstellen oder Überschreiben einer Datei. Es ist die lange Version, damit es leichter verstanden werden kann.

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;

public class writer {
    public void writing() {
        try {
            //Whatever the file path is.
            File statText = new File("E:/Java/Reference/bin/images/statsTest.txt");
            FileOutputStream is = new FileOutputStream(statText);
            OutputStreamWriter osw = new OutputStreamWriter(is);    
            Writer w = new BufferedWriter(osw);
            w.write("POTATO!!!");
            w.close();
        } catch (IOException e) {
            System.err.println("Problem writing to the file statsTest.txt");
        }
    }

    public static void main(String[]args) {
        writer write = new writer();
        write.writing();
    }
}
Draeven
quelle
39

Eine sehr einfache Möglichkeit, eine Datei in Java zu erstellen und in diese zu schreiben:

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;

public class CreateFiles {

    public static void main(String[] args) {
        try{
            // Create new file
            String content = "This is the content to write into create file";
            String path="D:\\a\\hi.txt";
            File file = new File(path);

            // If file doesn't exists, then create it
            if (!file.exists()) {
                file.createNewFile();
            }

            FileWriter fw = new FileWriter(file.getAbsoluteFile());
            BufferedWriter bw = new BufferedWriter(fw);

            // Write in file
            bw.write(content);

            // Close connection
            bw.close();
        }
        catch(Exception e){
            System.out.println(e);
        }
    }
}
Anuj Dhiman
quelle
7
Der File.exists()/createNewFile()Code hier ist sowohl sinnlos als auch verschwenderisch. Das Betriebssystem muss bereits genau das Gleiche tun, wenn das new FileWriter()erstellt wird. Sie zwingen alles zweimal.
Marquis von Lorne
1
Die Datei File.exists () / createNewFile () ist nicht sinnlos und verschwenderisch. Ich suchte nach einer Möglichkeit, unterschiedlichen Code auszuführen, je nachdem, ob die Datei bereits vorhanden ist oder nicht. Das war sehr hilfreich.
KirstieBallance
2
Ich habe diese Methode verwendet, aber Sie müssen wissen, dass sie die Datei jedes Mal überschreibt. Wenn Sie möchten, dass es angehängt wird, falls die Datei vorhanden ist, müssen Sie FileWriterwie folgt instanziieren :new FileWriter(file.getAbsoluteFile(),true)
Adelin
2
Es ist sowohl sinnlos als auch verschwenderisch, aus dem Grund, den ich angegeben habe. Sie verursachen zwei Existenztests, zwei Kreationen und eine Löschung: und Sie führen hier keinen unterschiedlichen Code aus, je nachdem, ob die Datei bereits vorhanden ist oder nicht.
Marquis von Lorne
34

Verwenden:

try (Writer writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("myFile.txt"), StandardCharsets.UTF_8))) {
    writer.write("text to write");
} 
catch (IOException ex) {
    // Handle me
}  

Mit try()wird der Stream automatisch geschlossen. Diese Version ist kurz, schnell (gepuffert) und ermöglicht die Auswahl der Codierung.

Diese Funktion wurde in Java 7 eingeführt.

icl7126
quelle
5
Es sollte beachtet werden, dass dies eine Java 7-Funktion ist und daher in früheren Versionen von Java nicht funktioniert.
Dan Temple
3
Man könnte die "Konstante" StandardCharsets.UTF_8anstelle der "utf-8" -String verwenden (dies verhindert Tippfehler) ...new OutputStreamWriter(new FileOutputStream("myFile.txt"), StandardCharsets.UTF_8)...- java.nio.charset.StandardCharsetswird in Java 7 eingeführt
Ralph
20

Hier geben wir eine Zeichenfolge in eine Textdatei ein:

String content = "This is the content to write into a file";
File file = new File("filename.txt");
FileWriter fw = new FileWriter(file.getAbsoluteFile());
BufferedWriter bw = new BufferedWriter(fw);
bw.write(content);
bw.close(); // Be sure to close BufferedWriter

Wir können einfach eine neue Datei erstellen und Inhalte hinzufügen.

iKing
quelle
Beachten Sie, dass das Schließen von BufferedWriter ausreicht, da auch das Schließen des FileWriter erledigt wird.
Rbaleksandar
17

Da der Autor nicht angegeben hat, ob eine Lösung für Java-Versionen erforderlich ist, die EoL-geprüft wurden (sowohl von Sun als auch von IBM, und dies sind technisch die am weitesten verbreiteten JVMs), und aufgrund der Tatsache, dass die meisten Leute die Frage beantwortet zu haben scheinen Frage des Autors, bevor angegeben wurde, dass es sich um eine Textdatei (nicht binär) handelt , habe ich beschlossen, meine Antwort zu geben.


Erstens hat Java 6 im Allgemeinen das Ende seiner Lebensdauer erreicht, und da der Autor nicht angegeben hat, dass er Legacy-Kompatibilität benötigt, bedeutet dies vermutlich automatisch Java 7 oder höher (Java 7 wird von IBM noch nicht EoL-geprüft). Wir können uns also das Datei-E / A-Tutorial ansehen: https://docs.oracle.com/javase/tutorial/essential/io/legacy.html

Vor der Veröffentlichung von Java SE 7 war die Klasse java.io.File der Mechanismus, der für Datei-E / A verwendet wurde, hatte jedoch mehrere Nachteile.

  • Viele Methoden haben keine Ausnahmen ausgelöst, als sie fehlschlugen, sodass es unmöglich war, eine nützliche Fehlermeldung zu erhalten. Wenn beispielsweise das Löschen einer Datei fehlschlug, erhielt das Programm einen "Löschfehler", wusste jedoch nicht, ob dies daran lag, dass die Datei nicht vorhanden war, der Benutzer keine Berechtigungen hatte oder ein anderes Problem auftrat.
  • Die Umbenennungsmethode funktionierte plattformübergreifend nicht konsistent.
  • Es gab keine wirkliche Unterstützung für symbolische Links.
  • Es wurde mehr Unterstützung für Metadaten gewünscht, z. B. Dateiberechtigungen, Dateieigentümer und andere Sicherheitsattribute. Der Zugriff auf Dateimetadaten war ineffizient.
  • Viele der File-Methoden wurden nicht skaliert. Das Anfordern einer großen Verzeichnisliste über einen Server kann zu einem Stillstand führen. Große Verzeichnisse können auch Probleme mit Speicherressourcen verursachen und zu einem Denial-of-Service führen.
  • Es war nicht möglich, zuverlässigen Code zu schreiben, der rekursiv durch einen Dateibaum laufen und angemessen reagieren konnte, wenn kreisförmige symbolische Links vorhanden waren.

Na ja, das schließt java.io.File aus. Wenn eine Datei nicht geschrieben / angehängt werden kann, können Sie möglicherweise nicht einmal wissen, warum.


Wir können uns das Tutorial weiter ansehen: https://docs.oracle.com/javase/tutorial/essential/io/file.html#common

Wenn Sie alle Zeilen haben, die Sie im Voraus in die Textdatei schreiben (anhängen), lautet der empfohlene Ansatz https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html# write-java.nio.file.Path-java.lang.Iterable-java.nio.charset.Charset-java.nio.file.OpenOption ...-

Hier ist ein Beispiel (vereinfacht):

Path file = ...;
List<String> linesInMemory = ...;
Files.write(file, linesInMemory, StandardCharsets.UTF_8);

Ein weiteres Beispiel (anhängen):

Path file = ...;
List<String> linesInMemory = ...;
Files.write(file, linesInMemory, Charset.forName("desired charset"), StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE);

Wenn Sie Dateiinhalte während des Schreibens schreiben möchten : https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html#newBufferedWriter-java.nio.file.Path-java .nio.charset.Charset-java.nio.file.OpenOption ...-

Vereinfachtes Beispiel (Java 8 oder höher):

Path file = ...;
try (BufferedWriter writer = Files.newBufferedWriter(file)) {
    writer.append("Zero header: ").append('0').write("\r\n");
    [...]
}

Ein weiteres Beispiel (anhängen):

Path file = ...;
try (BufferedWriter writer = Files.newBufferedWriter(file, Charset.forName("desired charset"), StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE)) {
    writer.write("----------");
    [...]
}

Diese Methoden erfordern nur minimalen Aufwand seitens des Autors und sollten allen anderen beim Schreiben in [Text] -Dateien vorgezogen werden.

afk5min
quelle
"Wenn eine Datei nicht geschrieben / angehängt werden kann, können Sie möglicherweise nicht einmal wissen, warum" nicht korrekt ist. Sie werden genau wissen, warum FileNotFoundException.
Marquis von Lorne
"Viele Methoden haben keine Ausnahmen ausgelöst, wenn sie fehlgeschlagen sind. Daher war es unmöglich, eine nützliche Fehlermeldung zu erhalten. Wenn beispielsweise das Löschen einer Datei fehlschlug, erhielt das Programm einen" Fehler beim Löschen ", wusste jedoch nicht, ob dies der Fall war Die Datei war nicht vorhanden, der Benutzer hatte keine Berechtigungen oder es gab ein anderes Problem. "
afk5min
Lesen Sie, was ich geschrieben habe. " Wenn eine Datei nicht geschrieben / angehängt werden kann, können Sie möglicherweise nicht einmal eine nützliche Fehlermeldung erhalten" ist aus dem von mir angegebenen Grund falsch und bleibt es auch. Sie wechseln das Thema. Dein eigenes Thema.
Marquis von Lorne
Ich werde die integrierten Implementierungen für typische Dateisysteme (die in OpenJDK vorhanden wären, aber ich habe keinen Grund zu der Annahme, dass dieser Teil sich unter anderem im proprietären Oracle JDK oder im proprietären IBM JDK erheblich unterscheidet) untersuchen und aktualisieren Meine Antwort basiert auf diesen Erkenntnissen. Ihr Kommentar ist sinnvoll - nur weil "viele Methoden" Probleme haben können, hat der Autor klar angegeben, dass es nur die Operation zum Schreiben / Anhängen an Dateien ist, die ihn interessiert.
afk5min
Der Grund dafür ist, dass keine der von Ihnen aufgerufenen Methoden die entsprechenden Ausnahmen mit den entsprechenden Fehlermeldungen auslöst. Wenn Sie ein Gegenbeispiel haben, das Ihre Behauptung stützt, liegt es an Ihnen, es bereitzustellen.
Marquis von Lorne
16

Wenn Sie eine relativ schmerzfreie Erfahrung machen möchten, können Sie sich auch das Apache Commons IO-Paket ansehen , genauer gesagt die FileUtilsKlasse .

Vergessen Sie niemals, Bibliotheken von Drittanbietern zu überprüfen. Joda-Zeit für Datumsmanipulation, Apache Commons LangStringUtils für allgemeine Zeichenfolgenoperationen und dergleichen können Ihren Code lesbarer machen.

Java ist eine großartige Sprache, aber die Standardbibliothek ist manchmal etwas niedrig. Kraftvoll, aber dennoch niedrig.

Extraneon
quelle
1
Die einfachste Methode zum Schreiben von Dateien FileUtilsist static void write(File file, CharSequence data). Anwendungsbeispiel : import org.apache.commons.io.FileUtils; FileUtils.write(new File("example.txt"), "string with data");. FileUtilshat auch writeLines, was eine Collectionvon Zeilen nimmt.
Rory O'Kane
12

Wenn Sie aus irgendeinem Grund den Vorgang des Erstellens und Schreibens trennen möchten, touchlautet das Java-Äquivalent von

try {
   //create a file named "testfile.txt" in the current working directory
   File myFile = new File("testfile.txt");
   if ( myFile.createNewFile() ) {
      System.out.println("Success!");
   } else {
      System.out.println("Failure!");
   }
} catch ( IOException ioe ) { ioe.printStackTrace(); }

createNewFile()führt eine Existenzprüfung und eine Datei atomar durch. Dies kann nützlich sein, wenn Sie beispielsweise vor dem Schreiben sicherstellen möchten, dass Sie der Ersteller der Datei sind.

Mark Peters
quelle
1
[touch] aktualisiert auch den Zeitstempel der Datei als Nebeneffekt (falls bereits vorhanden). Hat dies auch diese Nebenwirkung?
Ape-inago
@ Ape-inago: Auf meinem System war dies sicherlich nicht der Fall (es gibt nur false zurück und hat keine Auswirkungen auf die Datei). Ich meinte nicht touchim allgemeinen Sinne, sondern in seiner üblichen sekundären Verwendung, eine Datei zu erstellen, ohne Daten darauf zu schreiben. Der dokumentierte Zweck von touch besteht darin, den Zeitstempel in der Datei zu aktualisieren. Das Erstellen der Datei, wenn sie nicht vorhanden ist, ist der eigentliche Nebeneffekt und kann mit einem Schalter deaktiviert werden.
Mark Peters
Aus irgendeinem Grund wie was? Diese exists()/createNewFile()Sequenzen sind buchstäblich eine Verschwendung von Zeit und Raum.
Marquis von Lorne
12

Hier sind einige der möglichen Möglichkeiten, eine Datei in Java zu erstellen und zu schreiben:

Verwenden von FileOutputStream

try {
  File fout = new File("myOutFile.txt");
  FileOutputStream fos = new FileOutputStream(fout);
  BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(fos));
  bw.write("Write somthing to the file ...");
  bw.newLine();
  bw.close();
} catch (FileNotFoundException e){
  // File was not found
  e.printStackTrace();
} catch (IOException e) {
  // Problem when writing to the file
  e.printStackTrace();
}

Verwenden von FileWriter

try {
  FileWriter fw = new FileWriter("myOutFile.txt");
  fw.write("Example of content");
  fw.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when writing to the file
  e.printStackTrace();
}

Verwenden von PrintWriter

try {
  PrintWriter pw = new PrintWriter("myOutFile.txt");
  pw.write("Example of content");
  pw.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when writing to the file
  e.printStackTrace();
}

Verwenden von OutputStreamWriter

try {
  File fout = new File("myOutFile.txt");
  FileOutputStream fos = new FileOutputStream(fout);
  OutputStreamWriter osw = new OutputStreamWriter(fos);
  osw.write("Soe content ...");
  osw.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when writing to the file
  e.printStackTrace();
}

Weitere Informationen zum Lesen und Schreiben von Dateien in Java finden Sie in diesem Tutorial .

Mehdi
quelle
Ich frage mich nur ... sollte das nicht FileWriteroder OutputStreamWriterin einem endgültigen Block geschlossen werden?
Wolfgang Schreurs
@WolfgangSchreurs, Ja, es ist noch besser, ich muss die Variablendeklaration aus dem Try-Block verschieben, um das zu können.
Mehdi
Ich habe gerade herausgefunden, dass bei Verwendung von Auto-Closable, wenn auch sauberer, keine Variable außerhalb des Blocks deklariert werden muss und Ressourcen automatisch geschlossen werden, selbst wenn eine Ausnahme auftritt (es muss explizit ein finally-Block hinzugefügt werden). Siehe: docs.oracle.com/javase/tutorial/essential/exceptions/…
Wolfgang Schreurs
Ich würde den Versuch mit Ressourcen als separates Beispiel hinzufügen (um verschiedene Möglichkeiten zu trennen). Sie wissen, dass SOF eine kollaborative Website ist. Ändern Sie die Antwort, wenn Sie das Recht haben möchten.
Mehdi
10

Verwenden:

JFileChooser c = new JFileChooser();
c.showOpenDialog(c);
File writeFile = c.getSelectedFile();
String content = "Input the data here to be written to your file";

try {
    FileWriter fw = new FileWriter(writeFile);
    BufferedWriter bw = new BufferedWriter(fw);
    bw.append(content);
    bw.append("hiiiii");
    bw.close();
    fw.close();
}
catch (Exception exc) {
   System.out.println(exc);
}
Rohit ZP
quelle
Dies ist der einfachste Weg, den ich gefunden habe ... alle Probleme sind hier gelöst und nur der Text muss eingefügt werden
Rohit ZP
10

Am besten verwenden Sie Java7: Java 7 bietet eine neue Arbeitsweise mit dem Dateisystem sowie eine neue Dienstprogrammklasse - Dateien. Mit der Files-Klasse können wir auch Dateien und Verzeichnisse erstellen, verschieben, kopieren, löschen. Es kann auch zum Lesen und Schreiben in eine Datei verwendet werden.

public void saveDataInFile(String data) throws IOException {
    Path path = Paths.get(fileName);
    byte[] strToBytes = data.getBytes();

    Files.write(path, strToBytes);
}

Schreiben mit FileChannel Wenn Sie mit großen Dateien arbeiten, kann FileChannel schneller als Standard-E / A sein. Der folgende Code schreibt mit FileChannel einen String in eine Datei:

public void saveDataInFile(String data) 
  throws IOException {
    RandomAccessFile stream = new RandomAccessFile(fileName, "rw");
    FileChannel channel = stream.getChannel();
    byte[] strBytes = data.getBytes();
    ByteBuffer buffer = ByteBuffer.allocate(strBytes.length);
    buffer.put(strBytes);
    buffer.flip();
    channel.write(buffer);
    stream.close();
    channel.close();
}

Schreiben Sie mit DataOutputStream

public void saveDataInFile(String data) throws IOException {
    FileOutputStream fos = new FileOutputStream(fileName);
    DataOutputStream outStream = new DataOutputStream(new BufferedOutputStream(fos));
    outStream.writeUTF(data);
    outStream.close();
}

Schreiben Sie mit FileOutputStream

Lassen Sie uns nun sehen, wie wir FileOutputStream verwenden können, um Binärdaten in eine Datei zu schreiben. Der folgende Code konvertiert einen String in Bytes und schreibt die Bytes mit einem FileOutputStream in eine Datei:

public void saveDataInFile(String data) throws IOException {
    FileOutputStream outputStream = new FileOutputStream(fileName);
    byte[] strToBytes = data.getBytes();
    outputStream.write(strToBytes);

    outputStream.close();
}

Schreiben mit PrintWriter Wir können einen PrintWriter verwenden, um formatierten Text in eine Datei zu schreiben:

public void saveDataInFile() throws IOException {
    FileWriter fileWriter = new FileWriter(fileName);
    PrintWriter printWriter = new PrintWriter(fileWriter);
    printWriter.print("Some String");
    printWriter.printf("Product name is %s and its price is %d $", "iPhone", 1000);
    printWriter.close();
}

Schreiben mit BufferedWriter: Verwenden Sie BufferedWriter, um einen String in eine neue Datei zu schreiben:

public void saveDataInFile(String data) throws IOException {
    BufferedWriter writer = new BufferedWriter(new FileWriter(fileName));
    writer.write(data);

    writer.close();
}

Fügen Sie der vorhandenen Datei einen String hinzu:

public void saveDataInFile(String data) throws IOException {
    BufferedWriter writer = new BufferedWriter(new FileWriter(fileName, true));
    writer.append(' ');
    writer.append(data);

    writer.close();
}
sajad abbasi
quelle
9

Ich denke, das ist der kürzeste Weg:

FileWriter fr = new FileWriter("your_file_name.txt"); // After '.' write
// your file extention (".txt" in this case)
fr.write("Things you want to write into the file"); // Warning: this will REPLACE your old file content!
fr.close();
ben
quelle
8

So erstellen Sie eine Datei, ohne eine vorhandene Datei zu überschreiben:

System.out.println("Choose folder to create file");
JFileChooser c = new JFileChooser();
c.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
c.showOpenDialog(c);
c.getSelectedFile();
f = c.getSelectedFile(); // File f - global variable
String newfile = f + "\\hi.doc";//.txt or .doc or .html
File file = new File(newfile);

try {
    //System.out.println(f);
    boolean flag = file.createNewFile();

    if(flag == true) {
        JOptionPane.showMessageDialog(rootPane, "File created successfully");
    }
    else {
        JOptionPane.showMessageDialog(rootPane, "File already exists");
    }
    /* Or use exists() function as follows:
        if(file.exists() == true) {
            JOptionPane.showMessageDialog(rootPane, "File already exists");
        }
        else {
            JOptionPane.showMessageDialog(rootPane, "File created successfully");
        }
    */
}
catch(Exception e) {
    // Any exception handling method of your choice
}
Aashima
quelle
7
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class FileWriterExample {
    public static void main(String [] args) {
        FileWriter fw= null;
        File file =null;
        try {
            file=new File("WriteFile.txt");
            if(!file.exists()) {
                file.createNewFile();
            }
            fw = new FileWriter(file);
            fw.write("This is an string written to a file");
            fw.flush();
            fw.close();
            System.out.println("File written Succesfully");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
Anurag Goel
quelle
Diese exists()/createNewFile()Sequenzen sind buchstäblich eine Verschwendung von Zeit und Raum.
Marquis von Lorne
6
package fileoperations;
import java.io.File;
import java.io.IOException;

public class SimpleFile {
    public static void main(String[] args) throws IOException {
        File file =new File("text.txt");
        file.createNewFile();
        System.out.println("File is created");
        FileWriter writer = new FileWriter(file);

        // Writes the content to the file
        writer.write("Enter the text that you want to write"); 
        writer.flush();
        writer.close();
        System.out.println("Data is entered into file");
    }
}
Suthan Srinivasan
quelle
Diese exists()/createNewFile()Sequenzen sind buchstäblich eine Verschwendung von Zeit und Raum.
Marquis von Lorne
5

Nur eine Zeile! pathund linesind Saiten

import java.nio.file.Files;
import java.nio.file.Paths;

Files.write(Paths.get(path), lines.getBytes());
Ran Adler
quelle
Ahem, der Autor hat explizit "Text" -Dateien angegeben. Und Textdateien bestehen aus Zeichen. Binärdateien bestehen aus Bytes. Abgesehen davon ist unklar, was ist lines. Wenn dies der Fall ist java.lang.String, werden beim Aufrufen getBytes()Bytes mit der Standardcodierung der Plattform erzeugt , was im allgemeinen Fall nicht sehr gut ist.
afk5min
5

Der einfachste Weg, den ich finden kann:

Path sampleOutputPath = Paths.get("/tmp/testfile")
try (BufferedWriter writer = Files.newBufferedWriter(sampleOutputPath)) {
    writer.write("Hello, world!");
}

Es wird wahrscheinlich nur für 1.7+ funktionieren.

qed
quelle
5

Für Java 7+ ist es einen Versuch wert:

 Files.write(Paths.get("./output.txt"), "Information string herer".getBytes());

Es sieht vielversprechend aus ...

Olu Smith
quelle
4

Wenn wir Java 7 und höher verwenden und auch den Inhalt kennen, der der Datei hinzugefügt (angehängt) werden soll, können wir die newBufferedWriter- Methode im NIO-Paket verwenden.

public static void main(String[] args) {
    Path FILE_PATH = Paths.get("C:/temp", "temp.txt");
    String text = "\n Welcome to Java 8";

    //Writing to the file temp.txt
    try (BufferedWriter writer = Files.newBufferedWriter(FILE_PATH, StandardCharsets.UTF_8, StandardOpenOption.APPEND)) {
        writer.write(text);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Es gibt einige Punkte zu beachten:

  1. Es ist immer eine gute Angewohnheit, die Zeichensatzcodierung anzugeben, und dafür haben wir eine Konstante in der Klasse StandardCharsets.
  2. Der Code verwendet eine try-with-resourceAnweisung, in der Ressourcen nach dem Versuch automatisch geschlossen werden.

OP hat zwar nicht gefragt, aber nur für den Fall, dass wir nach Zeilen mit einem bestimmten Schlüsselwort suchen möchten, z. B. können confidentialwir Stream-APIs in Java verwenden:

//Reading from the file the first line which contains word "confidential"
try {
    Stream<String> lines = Files.lines(FILE_PATH);
    Optional<String> containsJava = lines.filter(l->l.contains("confidential")).findFirst();
    if(containsJava.isPresent()){
        System.out.println(containsJava.get());
    }
} catch (IOException e) {
    e.printStackTrace();
}
akhil_mittal
quelle
4

Lesen und Schreiben von Dateien mithilfe von Eingabe- und Ausgabestream:

//Coded By Anurag Goel
//Reading And Writing Files
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;


public class WriteAFile {
    public static void main(String args[]) {
        try {
            byte array [] = {'1','a','2','b','5'};
            OutputStream os = new FileOutputStream("test.txt");
            for(int x=0; x < array.length ; x++) {
                os.write( array[x] ); // Writes the bytes
            }
            os.close();

            InputStream is = new FileInputStream("test.txt");
            int size = is.available();

            for(int i=0; i< size; i++) {
                System.out.print((char)is.read() + " ");
            }
            is.close();
        } catch(IOException e) {
            System.out.print("Exception");
        }
    }
}
Anurag Goel
quelle
4

Fügen Sie einfach dieses Paket hinzu:

java.nio.file

Und dann können Sie diesen Code verwenden, um die Datei zu schreiben:

Path file = ...;
byte[] buf = ...;
Files.write(file, buf);
Peter Mortensen
quelle
4

Verwenden Sie in Java 8 "Dateien und Pfade" und das Konstrukt "Try-with-Resources".

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

public class WriteFile{
    public static void main(String[] args) throws IOException {
        String file = "text.txt";
        System.out.println("Writing to file: " + file);
        // Files.newBufferedWriter() uses UTF-8 encoding by default
        try (BufferedWriter writer = Files.newBufferedWriter(Paths.get(file))) {
            writer.write("Java\n");
            writer.write("Python\n");
            writer.write("Clojure\n");
            writer.write("Scala\n");
            writer.write("JavaScript\n");
        } // the file will be automatically closed
    }
}
praveenraj4ever
quelle
3

Es gibt einige einfache Möglichkeiten, wie:

File file = new File("filename.txt");
PrintWriter pw = new PrintWriter(file);

pw.write("The world I'm coming");
pw.close();

String write = "Hello World!";

FileWriter fw = new FileWriter(file);
BufferedWriter bw = new BufferedWriter(fw);

fw.write(write);

fw.close();
imvp
quelle
bwwird nicht verwendet.
Marquis von Lorne
Und der Punkt des Überschreibens der Datei mit neuem Inhalt ist nicht angegeben.
Marquis von Lorne
3

Sie können sogar eine temporäre Datei mithilfe einer Systemeigenschaft erstellen , die unabhängig von dem verwendeten Betriebssystem ist.

File file = new File(System.*getProperty*("java.io.tmpdir") +
                     System.*getProperty*("file.separator") +
                     "YourFileName.txt");
Muhammed Sayeed
quelle
2

Mit der Guava-Bibliothek von Google können wir sehr einfach eine Datei erstellen und in diese schreiben.

package com.zetcode.writetofileex;

import com.google.common.io.Files;
import java.io.File;
import java.io.IOException;

public class WriteToFileEx {

    public static void main(String[] args) throws IOException {

        String fileName = "fruits.txt";
        File file = new File(fileName);

        String content = "banana, orange, lemon, apple, plum";

        Files.write(content.getBytes(), file);
    }
}

Im Beispiel wird eine neue fruits.txtDatei im Projektstammverzeichnis erstellt.

Jan Bodnar
quelle
2

Sammlung mit Kunden lesen und in Datei speichern, mit JFilechooser.

private void writeFile(){

    JFileChooser fileChooser = new JFileChooser(this.PATH);
    int retValue = fileChooser.showDialog(this, "Save File");

    if (retValue == JFileChooser.APPROVE_OPTION){

        try (Writer fileWrite = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileChooser.getSelectedFile())))){

            this.customers.forEach((c) ->{
                try{
                    fileWrite.append(c.toString()).append("\n");
                }
                catch (IOException ex){
                    ex.printStackTrace();
                }
            });
        }
        catch (IOException e){
            e.printStackTrace();
        }
    }
}
Hasskell
quelle
2

Es gibt mindestens mehrere Möglichkeiten, eine Datei zu erstellen und in diese zu schreiben:

Kleine Dateien (1.7)

Sie können eine der Schreibmethoden verwenden, um Bytes oder Zeilen in eine Datei zu schreiben.

Path file = Paths.get("path-to-file");
byte[] buf = "text-to-write-to-file".;
Files.write(file, buf);

Diese Methoden erledigen den größten Teil der Arbeit für Sie, z. B. das Öffnen und Schließen des Streams, sind jedoch nicht für die Verarbeitung großer Dateien vorgesehen.

Schreiben einer größeren Datei mithilfe von gepufferten Stream-E / A. (1.7)

Das java.nio.filePaket unterstützt Kanal-E / A, die Daten in Puffern verschieben und einige der Ebenen umgehen, die Stream-E / A-Engpässe verursachen können.

String s = "much-larger-text-to-write-to-file";
try (BufferedWriter writer = Files.newBufferedWriter(file, StandardCharsets.UTF_8)) {
    writer.write(s, 0, s.length());
}

Dieser Ansatz ist aufgrund seiner effizienten Leistung besonders bei der Ausführung einer großen Anzahl von Schreibvorgängen bevorzugt. Gepufferte Operationen haben diesen Effekt, da sie nicht für jedes einzelne Byte die Schreibmethode des Betriebssystems aufrufen müssen, wodurch kostspielige E / A-Operationen reduziert werden.

Verwenden der NIO-API zum Kopieren (und Erstellen einer neuen) einer Datei mit einem Outputstream (1.7)

Path oldFile = Paths.get("existing-file-path");
Path newFile = Paths.get("new-file-path");
try (OutputStream os = new FileOutputStream(newFile.toFile())) {
    Files.copy(oldFile, os);
}

Es gibt auch zusätzliche Methoden, mit denen alle Bytes aus einem Eingabestream in eine Datei kopiert werden können.

FileWriter (Text) (<1,7)

Schreibt direkt in eine Datei (weniger Leistung) und sollte nur verwendet werden, wenn die Anzahl der Schreibvorgänge geringer ist. Wird verwendet, um zeichenorientierte Daten in eine Datei zu schreiben.

String s= "some-text";
FileWriter fileWriter = new FileWriter("C:\\path\\to\\file\\file.txt");
fileWriter.write(fileContent);
fileWriter.close();

FileOutputStream (binär) (<1,7)

FileOutputStream ist zum Schreiben von Streams von Rohbytes wie Bilddaten gedacht.

byte data[] = "binary-to-write-to-file".getBytes();
FileOutputStream out = new FileOutputStream("file-name");
out.write(data);
out.close();

Bei diesem Ansatz sollte in Betracht gezogen werden, immer ein Array von Bytes zu schreiben, anstatt jeweils ein Byte zu schreiben. Die Beschleunigung kann erheblich sein - bis zu 10-mal höher oder höher. Daher wird empfohlen, die write(byte[])Methoden nach Möglichkeit zu verwenden.

Piotr Niewinski
quelle