Java: guardar/escribir cadena en un archivo

En este tutorial, guardaremos o escribiremos una cadena en un archivo en Java usando Files.writeString(), Files.write(), FileWriter, BufferedWriter y PrintWriter con formato.

Introducción

Guardar una cadena en archivos se puede hacer de varias maneras usando Java. En este artículo, mostraremos algunos métodos comunes para escribir una cadena en un archivo.

Aquí hay una lista de todas las clases y métodos que revisaremos:

Archivos.writeString()

Desde Java 11, la clase Files contiene un útil método de utilidad Files.writeString(). Este método viene en dos variantes. La forma más básica requiere una ‘Ruta’ del archivo para escribir y los contenidos textuales. La otra variante también acepta un CharSet opcional:

1
2
3
4
5
6
7
8
Path path = Paths.get("output.txt");
String contents = "Hello";

try {
    Files.writeString(path, contents, StandardCharsets.UTF_8);
} catch (IOException ex) {
    // Handle exception
}

Aquí hay poco espacio para la flexibilidad, pero funciona muy bien si necesita escribir algo en un archivo rápidamente.

Archivos.escribir()

Una cadena, como otros objetos, se puede convertir en un byte[]. El método Files.write() trata con bytes:

1
2
3
4
5
6
7
8
9
Path path = Paths.get("output.txt");
String someString = "Hello World";
byte[] bytes = someString.getBytes();

try {
    Files.write(path, bytes);
} catch (IOException ex) {
    // Handle exception
}

No hay necesidad de cerrar ningún recurso ya que no hemos abierto ningún recurso nosotros mismos.

FileWriter

FileWriter es una de las formas más sencillas de escribir algunos contenidos textuales en un archivo. Crearemos una instancia de File y la pasaremos al constructor FileWriter para "conectarlos".

Luego, simplemente usamos la instancia FileWriter para escribir en él:

1
2
3
4
5
6
File output = new File("output.txt");
FileWriter writer = new FileWriter(output);

writer.write("This text was written with a FileWriter");
writer.flush();
writer.close();

Después de usar el escritor, es importante vaciar y cerrar los recursos. Alternativamente, puedes hacer esto con la sintaxis prueba-con-recursos:

1
2
3
4
5
6
try(FileWriter writer = new FileWriter("output.txt")) {
    writer.write("This text was written with a FileWriter"); 
}
catch(IOException e){
    // Handle the exception
}

BufferedWriter

BufferedWriter es un objeto contenedor que se usa alrededor de objetos de tipo Writer. Si tenemos un Writer existente como FileWriter, podemos envolverlo dentro de un BuffereWriter.

BufferedWriter se usa mejor cuando hay múltiples operaciones write() para un archivo. En este caso, esas escrituras múltiples se almacenan temporalmente en un búfer interno y se escriben en un archivo solo cuando hay suficiente contenido. Esto evita tener que almacenar cada nuevo fragmento de texto en un archivo y, en su lugar, proporciona un búfer adecuado para el almacenamiento temporal.

Usar un BufferedWriter es mucho más eficiente que FileWriter para múltiples escrituras, pero no ayuda con una sola escritura.

De hecho, usar BufferedWriter para una sola escritura causaría una sobrecarga innecesaria. Para casos tan simples, FileWriter es una opción mucho mejor.

Vamos a crear un BufferedWriter:

1
BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"));

BufferedWriter y FileWriter extienden Writer por lo que tienen los mismos métodos:

1
2
3
4
5
6
try(BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
    writer.write("Written with BufferedWriter);
}
catch(IOException e){
    // Handle the exception
}

PrintWriter

PrintWriter nos permite formatear el texto antes de escribirlo. Contiene métodos a los que estamos acostumbrados, como printf(), println(), etc. Vamos a crear un PrintWriter:

1
2
File output = new File("output.txt");
PrintWriter writer = new PrintWriter(output);

Una mejor forma de trabajar con un PrintWriter es con la sintaxis pruebe con recursos:

1
2
3
4
5
try(PrintWriter writer = new PrintWriter(new FileWriter("output.txt"))) {
    // Write using the PrintWriter instance
} catch {
    // Handle Exception
}

Una vez que tengamos una instancia de PrintWriter, exploremos algunos de los métodos que proporciona.

PrintWriter con append()

PrintWriter, al igual que StringBuilder, proporciona el método append() que nos permite agregar contenidos al final de un archivo existente.

Vamos a agregar() algo de texto a un escritor vacío:

1
2
3
4
5
6
writer.append("Welcome to my fruit store! From me, you can buy:\n");
writer.append("Apples");
writer.append("\n");
writer.append("Oranges");
writer.append("\n");
writer.append("Bananas");

El método append() devuelve el objeto PrintWriter al que fue llamado. Esto hace posible encadenar métodos append() y organizarlos mejor:

1
2
writer.append("Welcome to my fruit store! From me, you can buy:\n");
writer.append("Apples\n").append("Oranges\n").append("Bananas\n");

PrintWriter con print()

PrintWriter contiene métodos para la impresión formateada. Estos incluyen print(), printf() y println():

1
2
writer.print("Welcome to my fruit store %f", 2.0);
writer.printf("From me, you can buy %s and %s.", "apples", "oranges");

PrintWriter con escribir()

Con write(), podemos escribir muchos tipos diferentes de contenido textual en la transmisión. Los ejemplos incluyen matrices de caracteres, cadenas y enteros:

1
2
3
4
5
char[] hello = {'H', 'e', 'l', 'l', 'o', '!', '\n'};

writer.write(hello);
writer.write("Welcome to my fruit store\n");
writer.write("From me, you can buy apples and oranges");

El método write() solo acepta contenido sin opciones de formato, por lo que es similar a print(), pero no puede formatear cadenas.

Para finalizar cada "sesión" de PrintWriter ya sea agregando, imprimiendo o escribiendo, es importante vaciar y cerrar la secuencia:

1
2
writer.flush();
writer.close();

El método flush() "vacía" el contenido en el archivo y close() cierra permanentemente la transmisión.

Nota: Si usa la sintaxis pruebe con recursos, vaciará y cerrará la transmisión automáticamente.

Conclusión

En este artículo, mostramos algunos métodos comunes para escribir cadenas en archivos. Hay muchas opciones porque hay muchos casos de uso posibles.

Hemos cubierto los métodos Files.writeString(), Files.write(), así como las clases FileWriter, BufferedWriter y PrintWriter. `.

Licensed under CC BY-NC-SA 4.0