Wie erstelle ich eine Datei und schreibe sie in Java?

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

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

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:

• FileUtils.writeStringtoFile (..) von commons-io
• Files.write (..) von Guave

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

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();
}

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();
          }
        }
    }
}

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();
    }
}

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);
        }
    }
}

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.

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.

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.

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.

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.

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 .

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);
}

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();
}

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();

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
}

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();
        }
    }
}

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");
    }
}

Nur eine Zeile! pathund linesind Saiten

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

Files.write(Paths.get(path), lines.getBytes());

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.

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

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

Es sieht vielversprechend aus ...

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();
}

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");
        }
    }
}

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

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
    }
}

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();

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");

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.

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();
        }
    }
}

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.