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


699

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?

Respuestas:


727

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.


44
@Justin, también puede pasar una ruta absoluta (por ejemplo, "/tmp/filename.txt") al constructor FileOutputStream, para guardar el archivo en cualquier lugar que desee
Jonik

77
Por cierto, esto podría simplificarse utilizando los convenientes constructores que PrintStream ha tenido desde 1.5. Esto sería suficiente: PrintStream out = new PrintStream ("filename.txt");
Jonik

10
¿Necesitas cerrar ese archivo aunque en algún momento ...? codecodex.com/wiki/ASCII_file_save#Java
JStrahl

2
Desea utilizar try {} catch () {} finally {}, donde finalmente {} cierra el archivo si no es nulo.
Benas

23
En java8 puede probar (PrintStream ps = new PrintStream ("filename")) {ps.println (out); } esto se las arreglará para ti
Anton Chikin

245

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.


10
Solo una pequeña corrección, el segundo fragmento debería leer: FileUtils.writeStringToFile (nuevo archivo ("test.txt"), "Hello File");
pm_labs

3
Para aquellos de nosotros que preferimos la guayaba, también puede hacer esto .
Jonik

10
La función ahora está en desuso, debe agregar el juego de caracteres predeterminado ->FileUtils.writeStringToFile(new File("test.txt"), "Hello File", forName("UTF-8"));
Paul Fournel

97

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

@ XP1 Lo sé, esa es una gran mejora. He usado Lombok para esto en Java 6: solo ve @Cleanup new FileOutputStream(...)y listo.
Jorn

66
No olvides llamar a out.flush (); luego out.close ();
Alex Byrth

@AlexByrth, ¿por qué debería hacerlo?
Andrew Tobilko

1
Los archivos grandes se graban en segundo plano (otro hilo) y toman tiempo para grabar. Llamar a flush () asegura que todo se haya escrito en la siguiente línea, sincronizando la operación. Pero esto es opcional , pero es una buena práctica si maneja archivos grandes, como registros.
Alex Byrth

1
Tenga en cuenta que out.close () ya vacía el flujo, lo que significa que no es necesario llamar a out.flush ().
hjk321

90

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


3
En caso de que alguien más tarde se preguntara, la codificación sería el estándar de la plataforma.
Haakon Løtveit

55
content.getBytes(StandardCharsets.UTF_8)se puede usar para definir explícitamente la codificación.
John29

1
Tenga en cuenta que StandardOpenOption.CREATE no es el predeterminado StandardOpenOption.CREATE y StandardOpenOption.TRUNCATE_EXISTING es el predeterminado. Para usar el valor predeterminado simplemente elimine el tercer parámetro.
Tinus Tate

¡Por favor vea el comentario de Tinus Tate! ¿Cuál es el proceso para editar este ejemplo? Me pregunto cuántas miles de personas han tomado este ejemplo tal como es solo para descubrir que tienen resultados inesperados cuando sobrescriben un archivo con una cadena más corta. Como Tinus indica, TRUNCATE_EXISTING es crucial a menos que comprenda completamente y tenga una razón real para no querer truncar el archivo existente cuando se sobrescribe con una cadena más corta.
jch

1
¡En java 11 simplemente puede poner una cadena como segundo parámetro! ¡Hurra!
Dennis Glot el

78

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

44
Al eliminar todos los intentos / capturas y simplificarlos, también puedo hacerlo en una línea simplemente haciendo lo siguiente: (new BufferedWriter (new FileWriter (filename))). Write (str);
Artem Barger

66
Entonces, muestre su solución simple y agradable. Estaría encantado de aprender cómo hacerlo de una mejor manera.
Artem Barger

44
Ignora a los trolls ... siempre critican sin ofrecer su propia solución. Gracias por salvarme de escribir mi propio código / descargar una biblioteca adicional e introducir dependencia ...
nikib3ro

1
Parece que .close()no se lanza (al menos en Java 7?), ¿Es el último trycatch quizás redundante?
Kos

16
Tragar excepciones como esa te hará la vida más difícil cuando realmente ocurran excepciones. Por lo menos deberías volver a lanzarlos:throw new RuntimeException(e);
Roger Keays

65

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


20
No podría estar más en desacuerdo. Estas bibliotecas están ahí, por lo que no introducimos errores sutiles en una solución tan simple.
skaffman

3
No, obviamente no. Solo estoy en desacuerdo con que su solución podría no ser lo primero que arrojaría a alguien que es un programador principiante de Java. No estás sugiriendo que nunca has escrito algo así, ¿verdad?
duffymo

8
Sí, sí, pero eso fue antes de encontrar commons-io. Desde que descubrí eso, nunca he escrito ese tipo de cosas a mano, incluso en un proyecto de una clase. Si lo hubiera sabido desde el primer día, lo habría usado desde el primer día.
skaffman

55
Exactamente, pero eres un desarrollador experimentado. Su biografía dice que es un usuario de JBOSS / Spring, pero ciertamente no habría estado preparado para ninguno de los dos en su primer esfuerzo de "Hola, Mundo". No estoy en desacuerdo con el uso adecuado de las bibliotecas. Estoy diciendo que las personas que intentan un idioma por primera vez deberían tratar de conocerlo en la parte inferior, incluso si eso significa hacer cosas que descartarán más adelante cuando tengan experiencia y conozcan mejor.
duffymo

2
Implementé esto sin elementos comunes y obtuve una excepción menos que obvia. Luego implementé esto usando commons y me dijo exactamente qué estaba mal. Moraleja de la historia: ¿por qué vivir en la edad oscura si no es necesario?
SilentNot

22

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

2
Eso no cierra el archivo en caso de una excepción.
Tom Hawtin - tackline

1
@JanusTroelsen: Si es rechazado, cite la Declaración de prueba con recursos .
trashgod

22

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

13

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
}

2
Si estás usando guayaba, también la hay Charsets.UTF-8.
florian

2
@florian: En Charsets.UTF_8realidad es
Tim Büthe

La carpeta principal debe existir. Ejemplo: destination.mkdirs ().
AlikElzin-kilaka

2
Files.write (CharSequence from, File to, Charset charset) está en desuso en guava 26.0.
Pato Donald

Alternativa moderna de guayaba a archivos obsoletos. Escribir: Files.asCharSink(file, charset).write(text)
Vadzim

12

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>

12

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

Files.write (ruta, byte []) utilizará la codificación UTF-8. String.getBytes () usa la codificación de plataforma predeterminada. Entonces este es un problema potencial. Utilice string.getBytes (StandardCharsets.UTF_8)!
rmuller

11

Use esto, es muy legible:

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

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

También es una copia de una respuesta existente. : c
james.garriss

2
lo siento pero no inventé java8, no soy el único que usa esta línea. pero no es una copia pasada de otras respuestas a la misma pregunta
Ran Adler

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


10

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

10

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

Una palabra para el sabio: esto creará un nuevo archivo si no está allí, pero sobrescribirá los caracteres del archivo existente si lo está. Si los nuevos datos son más pequeños, eso significará que probablemente cree un archivo dañado. ¡Pregúntame cómo lo sé!
Chris Rae

Ok, como lo sabes?
ojblass

Simplemente use Files.write(targetPath, bytes);para sobrescribir el archivo entonces. Funcionará como se esperaba.
BullyWiiPlaza

8

Usando org.apache.commons.io.FileUtils:

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

6

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.


@Eric Leschinski: gracias por hacer que mi respuesta sea más profesional (también asumí que esto era exactamente lo que quería el OP, ya que esto es lo que realmente quiere la mayoría de las personas, simplemente volcar el texto y reemplazarlo)
bhathiya-perera

2
Una vez que la pregunta original ha sido respondida y el OP está satisfecho y desaparecido, páginas como esta solo sirven como un artefacto útil para las personas que llegan aquí desde una búsqueda en Google. Llegué a esta página para crear un mini anexo de texto a un archivo. Por lo tanto, es bueno hablar con toda la audiencia en lugar de con el OP después de que el OP se haya movido.
Eric Leschinski

3

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

1
aún mejor: use try-with-resources
Janus Troelsen

Sí, @JanusTroelsen tiene razón, mejor uso La declaración de prueba con recursos docs.oracle.com/javase/tutorial/essential/exceptions/…

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

}


1
Si bien este fragmento de código puede ser la solución, incluir una explicación realmente ayuda a mejorar la calidad de su publicación. Recuerde que está respondiendo la pregunta para los lectores en el futuro, y que esas personas podrían no conocer los motivos de su sugerencia de código.
Johan

close () nunca puede ser llamado. Por favor, mejore su respuesta agregando el manejo adecuado de los casos de error.
Boris Brodski

0

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.


0

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

    });

-1

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

1
Agregue el manejo de casos de error adecuado cerrando todos los recursos abiertos y propagando excepciones
Boris Brodski

¿Le importaría compartir los casos de manejo de código como lo recomendó? Gracias.
牟家宏

-1

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

Puede dejar un montón de recursos abiertos. Esta es una mala práctica, por favor, no hagas esto.
Boris Brodski
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.