Come posso salvare una stringa in un file di testo usando Java?

In Java, ho testo da un campo di testo in una variabile String chiamata "testo".

Come posso salvare il contenuto della variabile "text" in un file?

Se stai semplicemente emettendo testo, anziché qualsiasi dato binario, funzionerà quanto segue:

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

Quindi, scrivi la tua stringa su di essa, proprio come faresti con qualsiasi flusso di output:

out.println(text);

Avrai bisogno di una gestione delle eccezioni, come sempre. Assicurati di chiamareout.close() quando hai finito di scrivere.

Se si utilizza Java 7 o versioni successive, è possibile utilizzare l' istruzione " prova con risorse " che chiuderà automaticamente il tuo PrintStreamquando hai finito (cioè esci dal blocco) in questo modo:

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

Avrai comunque bisogno di lanciare esplicitamente java.io.FileNotFoundExceptioncome prima.

Apache Commons IO contiene alcuni ottimi metodi per farlo, in particolare FileUtils contiene il seguente metodo:

static void writeStringToFile(File file, String data) 

che consente di scrivere testo in un file in una chiamata di metodo:

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

Potresti anche considerare di specificare la codifica per il file.

Dai un'occhiata all'API dei file Java

un rapido esempio:

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

In Java 7 puoi fare questo:

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

Maggiori informazioni qui: http://www.drdobbs.com/jvm/java-se-7-new-file-io/231600403

Ho appena fatto qualcosa di simile nel mio progetto. Utilizzare FileWriter semplifica parte del tuo lavoro. E qui puoi trovare un bel 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)
    {
    }
}

Utilizzare FileUtils.writeStringToFile()da Apache Commons IO . Non è necessario reinventare questa ruota in particolare.

Puoi usare il codice di modifica qui sotto per scrivere il tuo file da qualunque classe o funzione stia gestendo il testo. Ci si chiede però perché il mondo abbia bisogno di un nuovo editor di testo ...

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 la java.nio.file.Filesclasse è stata estesa da due nuovi metodi di utilità per scrivere una stringa in un file. Il primo metodo (vedere JavaDoc qui ) utilizza il set di caratteri UTF-8 come predefinito:

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

E il secondo metodo (vedi JavaDoc qui ) consente di specificare un singolo set di caratteri:

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

Entrambi i metodi hanno un parametro Varargs opzionale per l'impostazione delle opzioni di gestione dei file (vedere JavaDoc qui ). L'esempio seguente creerebbe un file inesistente o aggiungerebbe la stringa a un file esistente:

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

Preferisco fare affidamento sulle librerie quando possibile per questo tipo di operazione. Questo mi rende meno propenso a omettere accidentalmente un passaggio importante (come l'errore di lupo fatto sopra). Alcune librerie sono suggerite sopra, ma la mia preferita per questo tipo di cose è Google Guava . Guava ha una classe chiamata Files che funziona bene per questa attività:

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

Usa API Apache Commons IO. È semplice

Usa API come

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

Dipendenza di Maven

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

Nel caso in cui sia necessario creare un file di testo basato su una singola stringa:

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

Usa questo, è molto leggibile:

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

Puoi inserire questo metodo nelle tue classi. Se si utilizza questo metodo in una classe con un metodo principale, modificare questa classe in statica aggiungendo la parola chiave statica. In entrambi i casi dovrai importare java.io. * per farlo funzionare, altrimenti File, FileWriter e BufferedWriter non verranno riconosciuti.

Potresti farlo:

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

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

Utilizzando org.apache.commons.io.FileUtils:

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

Se ti interessa solo spingere un blocco di testo in un file, questo lo sovrascriverà ogni volta.

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

Questo esempio consente all'utente di selezionare un file utilizzando un selettore di file.

È meglio chiudere il writer / outputstream in un blocco finally, nel caso in cui succeda qualcosa

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

}

Penso che il modo migliore sia usare 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));

Vedi javadoc :

Scrivi righe di testo in un file. Ogni riga è una sequenza di caratteri e viene scritta nel file in sequenza con ogni riga terminata dal separatore di riga della piattaforma, come definito dalla proprietà di sistema line.separator. I caratteri vengono codificati in byte utilizzando il set di caratteri specificato.

Il parametro options consente di specificare come viene creato o aperto il file. Se non sono presenti opzioni, questo metodo funziona come se fossero presenti le opzioni CREATE, TRUNCATE_EXISTING e WRITE. In altre parole, apre il file per la scrittura, creando il file se non esiste o inizialmente troncando un file normale esistente a una dimensione di 0. Il metodo assicura che il file venga chiuso quando tutte le righe sono state scritte ( oppure viene generato un errore I / O o un'altra eccezione di runtime). Se si verifica un errore I / O, è possibile che ciò avvenga dopo che il file è stato creato o troncato o dopo che alcuni byte sono stati scritti nel file.

Notare che. Vedo che le persone hanno già risposto con Java integrato Files.write, ma la cosa speciale nella mia risposta che nessuno sembra menzionare è la versione sovraccarica del metodo che accetta una Iterable di CharSequence (cioè String), invece di un byte[]array, quindi text.getBytes()non è richiesto , che è un po 'più pulito penso.

Se si desidera mantenere i caratteri di ritorno a capo dalla stringa in un file, ecco un esempio di codice:

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

    });

Il mio modo è basato sullo streaming a causa dell'esecuzione su tutte le versioni di Android e le esigenze di risorse di ricerca come URL / URI, qualsiasi suggerimento è il benvenuto.

Per quanto riguarda, gli stream (InputStream e OutputStream) trasferiscono i dati binari, quando lo sviluppatore va a scrivere una stringa in un flusso, devono prima convertirlo in byte o, in altre parole, codificarlo.

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

Puoi usare ArrayList per mettere tutto il contenuto di TextArea come esempio, e inviare come parametro chiamando il salvataggio, poiché lo scrittore ha appena scritto le righe di stringa, quindi usiamo il "per" riga per riga per scrivere la nostra ArrayList alla fine saremo contenti di TextArea in file txt. se qualcosa non ha senso, mi dispiace è traduttore Google e io che non parlo inglese.

Guarda il Blocco note di Windows, non salta sempre le linee e mostra tutto in una riga, usa 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);     
    }   
}