Wie erstelle ich eine Datei und schreibe in Java darauf?

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 Hilfsprogramme:

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

Beachten Sie auch, dass Sie ein FileWriter verwenden können , aber es wird die Standardcodierung verwendet, was häufig eine schlechte Idee ist - es ist am besten, die anzugeben explizit codieren.

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 sofort generiert werden soll), ist der Zusatz Java.nio.file.Files in Java 7 als Teil von native I/O bietet den einfachsten und effizientesten Weg, um Ihre Ziele zu erreichen.

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

Das folgende Beispiel erstellt und schreibt in 6 verschiedene Dateien, um zu veranschaulichen, wie es verwendet werden kann:

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

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.

Eine sehr einfache Möglichkeit, eine Datei in Java zu erstellen und 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);
        }
    }
}

Hier geben wir einen String 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 auf einfache Weise eine neue Datei erstellen und Inhalte hinzufügen.

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

Erstens hat Java 6 im Allgemeinen das Lebensende 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 ist noch nicht EoL-fähig) IBM). Wir können uns also gleich das Datei-I/O-Tutorial ansehen: https://docs.Oracle.com/javase/tutorial/essential/io/legacy.html

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

• Bei vielen Methoden wurden keine Ausnahmen ausgelöst, als sie fehlschlugen. Daher war es unmöglich, eine nützliche Fehlermeldung zu erhalten. Wenn beispielsweise das Löschen einer Datei fehlschlägt, erhält das Programm die Meldung "Löschen fehlgeschlagen". Es würde jedoch nicht erfahren, ob die Datei nicht vorhanden ist, der Benutzer keine Berechtigungen hat oder ein anderes Problem vorliegt.
• 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 waren nicht skalierbar. Das Anfordern einer großen Verzeichnisliste über einen Server kann zu einem Absturz führen. Große Verzeichnisse können auch Speicherressourcenprobleme verursachen, die zu einem Denial-of-Service führen.
• Es war nicht möglich, zuverlässigen Code zu schreiben, der einen Dateibaum rekursiv durchlaufen und angemessen reagieren konnte, wenn kreisförmige symbolische Verknüpfungen 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 das Tutorial weiter lesen: 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 unterwegs Dateiinhalte 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 vorgezogen werden, wenn in [Text] -Dateien geschrieben wird.

Wenn Sie ein relativ schmerzfreies Erlebnis wünschen, können Sie sich auch das Paket Apache Commons IO ansehen, genauer gesagt die Klasse FileUtils .

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

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

Hier sind einige der möglichen Methoden zum Erstellen und Schreiben einer Datei in Java:

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 finden Sie in diesem Tutorial zu How to Lesen und Schreiben von Dateien in Java .

Wenn Sie aus irgendeinem Grund das Erstellen und Schreiben trennen möchten, ist das Java Äquivalent zu touch

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 durch und legt eine Datei atomar an. Dies kann nützlich sein, wenn Sie sicherstellen möchten, dass Sie der Ersteller der Datei sind, bevor Sie beispielsweise darauf schreiben.

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

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

Der beste Weg ist, Java7 zu verwenden: Java 7 führt eine neue Art der Arbeit mit dem Dateisystem ein, zusammen mit einer neuen Dienstprogrammklasse - Files. Mit der Files-Klasse können wir auch Dateien und Verzeichnisse erstellen, verschieben, kopieren und löschen. Es kann auch zum Lesen und Schreiben einer Datei verwendet werden.

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

    Files.write(path, strToBytes);
}

Write with FileChannel Wenn Sie mit großen Dateien arbeiten, kann FileChannel schneller als Standard-E/A sein. Der folgende Code schreibt einen String mit FileChannel 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 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 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();
}

Write with BufferedWriter: benutze 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üge einen String an die vorhandene Datei an:

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

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

Es ist einen Versuch wert für Java 7+:

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

Es sieht vielversprechend aus ...

Nur eine Zeile! path und line sind Strings

import Java.nio.file.Files;
import Java.nio.file.Paths;

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

Am einfachsten finde ich:

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.

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

Datei lesen und schreiben mit Input und Outputstream:

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

Wenn wir Java 7 und höher verwenden und 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 Zeichensatzkodierung anzugeben, und dafür haben wir eine Konstante in der Klasse StandardCharsets.
2. Der Code verwendet die Anweisung try-with-resource, in der Ressourcen nach dem Versuch automatisch geschlossen werden.

Obwohl OP nicht gefragt hat, sondern nur für den Fall, dass wir nach Zeilen mit einem bestimmten Schlüsselwort suchen möchten, z. confidential Wir können 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();
}

Sie können sogar eine temporäre Datei mit einem Systemeigenschaft erstellen, das unabhängig von dem von Ihnen verwendeten Betriebssystem ist.

File file = new File(System.*getProperty*("Java.io.tmpdir") +
                     System.*getProperty*("file.separator") +
                     "YourFileName.txt");

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

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

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

Das Beispiel erstellt eine neue fruits.txt -Datei im Projektstammverzeichnis.

Erstellen einer Beispieldatei:

try {
    File file = new File ("c:/new-file.txt");
    if(file.createNewFile()) {
        System.out.println("Successful created!");
    }
    else {
        System.out.println("Failed to create!");
    }
}
catch (IOException e) {
    e.printStackTrace();
}