¿Cómo guardo una cadena en un archivo de texto usando Java?

En Java, tengo texto de un campo de texto en una variable de cadena llamada "texto".

¿Cómo puedo guardar el contenido de la variable "texto" en un archivo?

Si simplemente está generando texto, en lugar de cualquier dato binario, lo siguiente funcionará:

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

Luego, escriba su cadena en él, tal como lo haría en cualquier flujo de salida:

out.println(text);

Necesitará manejo de excepciones, como siempre. Asegúrate de llamarout.close() cuando haya terminado de escribir.

Si está utilizando Java 7 o posterior, puede usar la " declaración de prueba con recursos " que cerrará automáticamente PrintStreamcuando termine (es decir, salga del bloque) de esta manera:

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

Aún necesitará lanzar explícitamente el java.io.FileNotFoundExceptioncomo antes.

Apache Commons IO contiene algunos métodos excelentes para hacer esto, en particular FileUtils contiene el siguiente método:

static void writeStringToFile(File file, String data) 

que le permite escribir texto en un archivo en una llamada de método:

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

También puede considerar especificar la codificación del archivo también.

Echa un vistazo a la API de Java File

Un ejemplo rápido:

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

En Java 7 puedes hacer esto:

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

Hay más información aquí: http://www.drdobbs.com/jvm/java-se-7-new-file-io/231600403

Acabo de hacer algo similar en mi proyecto. Usar FileWriter simplificará parte de su trabajo. Y aquí puedes encontrar un buen 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)
    {
    }
}

Uso FileUtils.writeStringToFile()de Apache Commons IO . No es necesario reinventar esta rueda en particular.

Puede usar la modificación del código a continuación para escribir su archivo desde cualquier clase o función que maneje el texto. Sin embargo, uno se pregunta por qué el mundo necesita un nuevo editor de texto ...

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

En Java 11, la java.nio.file.Filesclase se amplió mediante dos nuevos métodos de utilidad para escribir una cadena en un archivo. El primer método (ver JavaDoc aquí ) usa el juego de caracteres juego de UTF-8 como predeterminado:

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

Y el segundo método (ver JavaDoc aquí ) permite especificar un conjunto de caracteres individual:

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

Ambos métodos tienen un parámetro opcional de Varargs para configurar las opciones de manejo de archivos (ver JavaDoc aquí ). El siguiente ejemplo crearía un archivo no existente o agregaría la cadena a uno existente:

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

Prefiero confiar en las bibliotecas siempre que sea posible para este tipo de operación. Esto hace que sea menos probable que omita accidentalmente un paso importante (como el error que Wolfsnipes cometió anteriormente). Algunas bibliotecas se sugieren anteriormente, pero mi favorito para este tipo de cosas es Google Guava . Guayaba tiene una clase llamada Archivos que funciona muy bien para esta tarea:

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

Utilice Apache Commons IO api. Es simple

Usar API como

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

Dependencia de Maven

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

En caso de que necesite crear un archivo de texto basado en una sola cadena:

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

Use esto, es muy legible:

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

Puedes insertar este método en tus clases. Si está utilizando este método en una clase con un método principal, cambie esta clase a estática agregando la palabra clave estática. De cualquier forma, deberá importar java.io. * para que funcione; de ​​lo contrario, File, FileWriter y BufferedWriter no se reconocerán.

Podrías hacer esto:

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

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

Usando org.apache.commons.io.FileUtils:

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

Si solo le importa empujar un bloque de texto al archivo, esto lo sobrescribirá cada vez.

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

Este ejemplo permite al usuario seleccionar un archivo usando un selector de archivos.

Es mejor cerrar el flujo de escritura / salida en un bloque finalmente, en caso de que ocurra algo

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

}

Creo que la mejor manera es usar 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));

Ver javadoc :

Escribir líneas de texto en un archivo. Cada línea es una secuencia de caracteres y se escribe en el archivo en secuencia con cada línea terminada por el separador de línea de la plataforma, según lo definido por la propiedad del sistema line.separator. Los caracteres se codifican en bytes utilizando el juego de caracteres especificado.

El parámetro de opciones especifica cómo se crea o abre el archivo. Si no hay opciones presentes, este método funciona como si las opciones CREATE, TRUNCATE_EXISTING y WRITE estuvieran presentes. En otras palabras, abre el archivo para escribir, crea el archivo si no existe o inicialmente trunca un archivo regular existente a un tamaño de 0. El método asegura que el archivo se cierre cuando se hayan escrito todas las líneas ( o se produce un error de E / S u otra excepción de tiempo de ejecución). Si se produce un error de E / S, puede hacerlo después de que el archivo se haya creado o truncado, o después de que se hayan escrito algunos bytes en el archivo.

Tenga en cuenta. Veo que la gente ya ha respondido con el Java incorporado Files.write, pero lo que es especial en mi respuesta que nadie parece mencionar es la versión sobrecargada del método que toma un Iterable de CharSequence (es decir, String), en lugar de una byte[]matriz, por text.getBytes()lo que no es necesario , que es un poco más limpio, creo.

Si desea mantener los caracteres de retorno de carro de la cadena en un archivo, aquí hay un ejemplo de código:

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

    });

Mi manera se basa en la transmisión debido a que se ejecuta en todas las versiones de Android y las necesidades de recursos de fecthing como URL / URI, cualquier sugerencia es bienvenida.

En lo que concierne, las secuencias (InputStream y OutputStream) transfieren datos binarios, cuando el desarrollador va a escribir una cadena en una secuencia, primero debe convertirla a bytes o, en otras palabras, codificarla.

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

Puede usar ArrayList para poner todos los contenidos de TextArea por ejemplo, y enviar como parámetro llamando al save, ya que el escritor acaba de escribir líneas de cadena, luego usamos "for" línea por línea para escribir nuestra ArrayList al final estaremos contentos con TextArea en el archivo txt. Si algo no tiene sentido, lo siento es Google Traductor y yo que no hablo inglés.

Mire el Bloc de notas de Windows, no siempre salta líneas y muestra todo en una línea, use 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);     
    }   
}