Wie speichere ich einen String mit Java in einer Textdatei?

In Java habe ich Text aus einem Textfeld in einer String-Variablen namens "text".

Wie kann ich den Inhalt der Variablen "text" in einer Datei speichern?

Wenn Sie lediglich Text und keine Binärdaten ausgeben, funktioniert Folgendes:

PrintWriter out = new PrintWriter("filename.txt");

Schreiben Sie dann Ihren String darauf, genau wie in jeden Ausgabestream:

out.println(text);

Sie benötigen wie immer eine Ausnahmebehandlung. Rufen out.close()Sie unbedingt an, wenn Sie mit dem Schreiben fertig sind.

Wenn Sie Java 7 oder höher verwenden, können Sie die Anweisung " try-with-resources " verwenden, mit der Sie automatisch geschlossen werden, PrintStreamwenn Sie damit fertig sind (dh den Block verlassen).

try (PrintWriter out = new PrintWriter("filename.txt")) {
    out.println(text);
}

Sie müssen das java.io.FileNotFoundExceptionwie zuvor noch explizit werfen .

Apache Commons IO enthält einige großartige Methoden, insbesondere FileUtils enthält die folgende Methode:

static void writeStringToFile(File file, String data) 

Damit können Sie in einem Methodenaufruf Text in eine Datei schreiben:

FileUtils.writeStringToFile(new File("test.txt"), "Hello File");

Möglicherweise möchten Sie auch die Codierung für die Datei angeben.

Schauen Sie sich die Java File API an

ein kurzes Beispiel:

try (PrintStream out = new PrintStream(new FileOutputStream("filename.txt"))) {
    out.print(text);
}

In Java 7 können Sie dies tun:

String content = "Hello File!";
String path = "C:/a.txt";
Files.write( Paths.get(path), content.getBytes());

Weitere Informationen finden Sie hier: http://www.drdobbs.com/jvm/java-se-7-new-file-io/231600403

Habe gerade etwas Ähnliches in meinem Projekt gemacht. Die Verwendung von FileWriter vereinfacht einen Teil Ihrer Arbeit. Und hier finden Sie ein schönes Tutorial .

BufferedWriter writer = null;
try
{
    writer = new BufferedWriter( new FileWriter( yourfilename));
    writer.write( yourstring);

}
catch ( IOException e)
{
}
finally
{
    try
    {
        if ( writer != null)
        writer.close( );
    }
    catch ( IOException e)
    {
    }
}

Verwendung FileUtils.writeStringToFile()von Apache Commons IO . Dieses spezielle Rad muss nicht neu erfunden werden.

Sie können den folgenden Code ändern, um Ihre Datei aus einer Klasse oder Funktion zu schreiben, die den Text verarbeitet. Man wundert sich jedoch, warum die Welt einen neuen Texteditor braucht ...

import java.io.*;

public class Main {

    public static void main(String[] args) {

        try {
            String str = "SomeMoreTextIsHere";
            File newTextFile = new File("C:/thetextfile.txt");

            FileWriter fw = new FileWriter(newTextFile);
            fw.write(str);
            fw.close();

        } catch (IOException iox) {
            //do stuff with exception
            iox.printStackTrace();
        }
    }
}

In Java 11 wurde die java.nio.file.FilesKlasse um zwei neue Dienstprogrammmethoden erweitert, um eine Zeichenfolge in eine Datei zu schreiben. Die erste Methode (siehe JavaDoc hier ) verwendet standardmäßig den Zeichensatz UTF-8 :

Files.writeString(Path.of("my", "path"), "My String");

Mit der zweiten Methode (siehe JavaDoc hier ) können Sie einen einzelnen Zeichensatz angeben:

Files.writeString(Path.of("my", "path"), "My String", StandardCharset.ISO_8859_1);

Beide Methoden verfügen über einen optionalen Varargs-Parameter zum Festlegen von Optionen für die Dateibehandlung (siehe JavaDoc hier ). Im folgenden Beispiel wird eine nicht vorhandene Datei erstellt oder die Zeichenfolge an eine vorhandene angehängt:

Files.writeString(Path.of("my", "path"), "String to append", StandardOpenOption.CREATE, StandardOpenOption.APPEND);

Ich bevorzuge es, wenn immer möglich, für diese Art von Operation auf Bibliotheken zu vertrauen. Dies macht es weniger wahrscheinlich, dass ich versehentlich einen wichtigen Schritt auslasse (wie die oben gemachten Fehler-Wolfsnipes). Einige Bibliotheken wurden oben vorgeschlagen, aber mein Favorit für diese Art von Dingen ist Google Guava . Guava hat eine Klasse namens " Dateien", die für diese Aufgabe gut geeignet ist :

// This is where the file goes.
File destination = new File("file.txt");
// This line isn't needed, but is really useful 
// if you're a beginner and don't know where your file is going to end up.
System.out.println(destination.getAbsolutePath());
try {
    Files.write(text, destination, Charset.forName("UTF-8"));
} catch (IOException e) {
    // Useful error handling here
}

Verwenden Sie die Apache Commons IO-API. Es ist einfach

Verwenden Sie API als

 FileUtils.writeStringToFile(new File("FileNameToWrite.txt"), "stringToWrite");

Maven-Abhängigkeit

<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.4</version>
</dependency>

Falls Sie eine Textdatei erstellen müssen, die auf einer einzelnen Zeichenfolge basiert:

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

public class StringWriteSample {
    public static void main(String[] args) {
        String text = "This is text to be saved in file";

        try {
            Files.write(Paths.get("my-file.txt"), text.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Verwenden Sie dies, es ist sehr gut lesbar:

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

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

import java.io.*;

private void stringToFile( String text, String fileName )
 {
 try
 {
    File file = new File( fileName );

    // if file doesnt exists, then create it 
    if ( ! file.exists( ) )
    {
        file.createNewFile( );
    }

    FileWriter fw = new FileWriter( file.getAbsoluteFile( ) );
    BufferedWriter bw = new BufferedWriter( fw );
    bw.write( text );
    bw.close( );
    //System.out.println("Done writing to " + fileName); //For testing 
 }
 catch( IOException e )
 {
 System.out.println("Error: " + e);
 e.printStackTrace( );
 }
} //End method stringToFile

Sie können diese Methode in Ihre Klassen einfügen. Wenn Sie diese Methode in einer Klasse mit einer Hauptmethode verwenden, ändern Sie diese Klasse in statisch, indem Sie das statische Schlüsselwort hinzufügen. In beiden Fällen müssen Sie java.io. * importieren, damit es funktioniert. Andernfalls werden File, FileWriter und BufferedWriter nicht erkannt.

Sie könnten dies tun:

import java.io.*;
import java.util.*;

class WriteText
{
    public static void main(String[] args)
    {   
        try {
            String text = "Your sample content to save in a text file.";
            BufferedWriter out = new BufferedWriter(new FileWriter("sample.txt"));
            out.write(text);
            out.close();
        }
        catch (IOException e)
        {
            System.out.println("Exception ");       
        }

        return ;
    }
};

Verwenden von Java 7:

public static void writeToFile(String text, String targetFilePath) throws IOException
{
    Path targetPath = Paths.get(targetFilePath);
    byte[] bytes = text.getBytes(StandardCharsets.UTF_8);
    Files.write(targetPath, bytes, StandardOpenOption.CREATE);
}

Verwenden von org.apache.commons.io.FileUtils:

FileUtils.writeStringToFile(new File("log.txt"), "my string", Charset.defaultCharset());

Wenn Sie nur einen Textblock in eine Datei verschieben möchten, wird dieser jedes Mal überschrieben.

JFileChooser chooser = new JFileChooser();
int returnVal = chooser.showSaveDialog(this);
if (returnVal == JFileChooser.APPROVE_OPTION) {
    FileOutputStream stream = null;
    PrintStream out = null;
    try {
        File file = chooser.getSelectedFile();
        stream = new FileOutputStream(file); 
        String text = "Your String goes here";
        out = new PrintStream(stream);
        out.print(text);                  //This will overwrite existing contents

    } catch (Exception ex) {
        //do something
    } finally {
        try {
            if(stream!=null) stream.close();
            if(out!=null) out.close();
        } catch (Exception ex) {
            //do something
        }
    }
}

In diesem Beispiel kann der Benutzer eine Datei mit einer Dateiauswahl auswählen.

Es ist besser, den Writer / Outputstream in einem finally-Block zu schließen, falls etwas passiert

finally{
   if(writer != null){
     try{
        writer.flush();
        writer.close();
     }
     catch(IOException ioe){
         ioe.printStackTrace();
     }
   }
}

private static void generateFile(String stringToWrite, String outputFile) {
try {       
    FileWriter writer = new FileWriter(outputFile);
    writer.append(stringToWrite);
    writer.flush();
    writer.close();
    log.debug("New File is generated ==>"+outputFile);
} catch (Exception exp) {
    log.error("Exception in generateFile ", exp);
}

}}

Ich denke, der beste Weg ist Files.write(Path path, Iterable<? extends CharSequence> lines, OpenOption... options):

String text = "content";
Path path = Paths.get("path", "to", "file");
Files.write(path, Arrays.asList(text));

Siehe javadoc :

Schreiben Sie Textzeilen in eine Datei. Jede Zeile ist eine Zeichenfolge und wird nacheinander in die Datei geschrieben, wobei jede Zeile durch das Zeilentrennzeichen der Plattform abgeschlossen wird, wie durch die Systemeigenschaft line.separator definiert. Zeichen werden mit dem angegebenen Zeichensatz in Bytes codiert.

Der Parameter options gibt an, wie die Datei erstellt oder geöffnet wird. Wenn keine Optionen vorhanden sind, funktioniert diese Methode so, als ob die Optionen CREATE, TRUNCATE_EXISTING und WRITE vorhanden wären. Mit anderen Worten, es öffnet die Datei zum Schreiben, erstellt die Datei, falls sie nicht vorhanden ist, oder schneidet eine vorhandene reguläre Datei zunächst auf eine Größe von 0 ab. Die Methode stellt sicher, dass die Datei geschlossen wird, wenn alle Zeilen geschrieben wurden ( oder ein E / A-Fehler oder eine andere Laufzeitausnahme wird ausgelöst). Wenn ein E / A-Fehler auftritt, kann dies geschehen, nachdem die Datei erstellt oder abgeschnitten wurde oder nachdem einige Bytes in die Datei geschrieben wurden.

Bitte beachten Sie. Ich sehe, dass die Leute bereits mit dem integrierten Java geantwortet haben Files.write, aber das Besondere an meiner Antwort, das niemand zu erwähnen scheint, ist die überladene Version der Methode, die anstelle eines byte[]Arrays eine Iterable of CharSequence (dh String) verwendet und daher text.getBytes()nicht erforderlich ist , was meiner Meinung nach etwas sauberer ist.

Wenn Sie die Wagenrücklaufzeichen aus der Zeichenfolge in einer Datei behalten möchten, finden Sie hier ein Codebeispiel:

    jLabel1 = new JLabel("Enter SQL Statements or SQL Commands:");
    orderButton = new JButton("Execute");
    textArea = new JTextArea();
    ...


    // String captured from JTextArea()
    orderButton.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent ae) {
            // When Execute button is pressed
            String tempQuery = textArea.getText();
            tempQuery = tempQuery.replaceAll("\n", "\r\n");
            try (PrintStream out = new PrintStream(new FileOutputStream("C:/Temp/tempQuery.sql"))) {
                out.print(tempQuery);
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(tempQuery);
        }

    });

Mein Weg basiert auf Streams, da er auf allen Android-Versionen läuft und Ressourcen wie URL / URI benötigt. Jeder Vorschlag ist willkommen.

Streams (InputStream und OutputStream) übertragen Binärdaten. Wenn Entwickler eine Zeichenfolge in einen Stream schreiben, müssen sie diese zuerst in Bytes konvertieren oder mit anderen Worten codieren.

public boolean writeStringToFile(File file, String string, Charset charset) {
    if (file == null) return false;
    if (string == null) return false;
    return writeBytesToFile(file, string.getBytes((charset == null) ? DEFAULT_CHARSET:charset));
}

public boolean writeBytesToFile(File file, byte[] data) {
    if (file == null) return false;
    if (data == null) return false;
    FileOutputStream fos;
    BufferedOutputStream bos;
    try {
        fos = new FileOutputStream(file);
        bos = new BufferedOutputStream(fos);
        bos.write(data, 0, data.length);
        bos.flush();
        bos.close();
        fos.close();
    } catch (IOException e) {
        e.printStackTrace();
        Logger.e("!!! IOException");
        return false;
    }
    return true;
}

Sie können die ArrayList verwenden, um beispielsweise den gesamten Inhalt der TextArea abzulegen und als Parameter zu senden, indem Sie save aufrufen, da der Writer gerade Zeichenfolgenzeilen geschrieben hat. Anschließend verwenden wir das "for" zeilenweise, um am Ende unsere ArrayList zu schreiben Wir werden TextArea in txt-Datei zufrieden sein. Wenn etwas keinen Sinn ergibt, tut es mir leid, ist Google Übersetzer und ich, die kein Englisch sprechen.

Beobachten Sie den Windows-Editor, er springt nicht immer Zeilen und zeigt alle in einer Zeile an. Verwenden Sie Wordpad ok.

private void SaveActionPerformed(java.awt.event.ActionEvent evt) {

    String NameFile = Name.getText();
    ArrayList< String > Text = new ArrayList< String >();

    Text.add(TextArea.getText());

    SaveFile(NameFile, Text);
}

public void SaveFile(String name, ArrayList< String> message) {

    path = "C:\\Users\\Paulo Brito\\Desktop\\" + name + ".txt";

    File file1 = new File(path);

    try {

        if (!file1.exists()) {

            file1.createNewFile();
        }


        File[] files = file1.listFiles();


        FileWriter fw = new FileWriter(file1, true);

        BufferedWriter bw = new BufferedWriter(fw);

        for (int i = 0; i < message.size(); i++) {

            bw.write(message.get(i));
            bw.newLine();
        }

        bw.close();
        fw.close();

        FileReader fr = new FileReader(file1);

        BufferedReader br = new BufferedReader(fr);

        fw = new FileWriter(file1, true);

        bw = new BufferedWriter(fw);

        while (br.ready()) {

            String line = br.readLine();

            System.out.println(line);

            bw.write(line);
            bw.newLine();

        }
        br.close();
        fr.close();

    } catch (IOException ex) {
        ex.printStackTrace();
        JOptionPane.showMessageDialog(null, "Error in" + ex);     
    }   
}