No sé si lo has notado también, pero cuando uno trabaja con archivos o tiene que enviar datos a la consola, resulta muy demorado escribir directamente en el flujo, sobre todo si es de manera repetitiva. De hecho, es como tener que escribir una gran cantidad de información, byte por byte o carácter por carácter: definitivamente el rendimiento de tu aplicación no será nada bueno.
Por eso, BufferedWriter en Java es tan útil. Al escribir en bloques grandes en lugar de hacerlo carácter por carácter, hace que el proceso sea mucho más rápido y menos complejo. Si estás desarrollando una aplicación que maneja muchos datos o archivos grandes, esta clase será tu aliada.
¿Qué es BufferedWriter en Java?
El BufferedWriter en Java es una clase que se utiliza para escribir texto en un flujo de salida, como puede ser un archivo o la consola. Es parecido a BufferedReader (que leemos en el flujo de entrada), solo que el BufferedWriter se asegura de que los datos se escriban en bloques grandes, para mejorar la velocidad y reducir la cantidad de operaciones de escritura.
BufferedWriter no escribe los datos directamente al destino, sino que primero los almacena en un búfer, y luego los escribe en bloque. Así es como mejora el rendimiento porque reduce las operaciones de escritura, lo cual sirve mucho cuando se trabaja con bastantes datos.
¿Cómo utilizar BufferedWriter en tus proyectos?
Con estos ejemplos prácticos que te dejo aquí, aprenderás a usar BufferedWriter en Java. La idea es que te ayuden a entender cómo implementarlo en tus proyectos y así mejorar tu flujo de trabajo.
Ejemplo 1: Escribe una cadena en un archivo
Uno de los usos más comunes de BufferedWriter en Java es escribir texto en un archivo. Con este ejemplo sencillo lograrás hacerlo:
import java.io.*;
public class EscribirArchivo {
public static void main(String[] args) {
String contenido = "Este es un ejemplo de uso de BufferedWriter en Java.";
try {
FileWriter archivo = new FileWriter("ejemplo.txt");
BufferedWriter escritor = new BufferedWriter(archivo);
escritor.write(contenido); // Escribimos la cadena en el archivo
escritor.newLine(); // Añadimos una nueva línea
escritor.flush(); // Aseguramos que se escriban los datos
escritor.close(); // Cerramos el BufferedWriter
System.out.println("¡Archivo escrito con éxito!");
} catch (IOException e) {
e.printStackTrace();
}
}
}
Lo que hice en este ejemplo fue crear un archivo, el cual nombré ejemplo.txt y escribí una cadena de texto en él con ayuda del BufferedWriter.
Ten en cuenta que hay que usar el método flush() para asegurarnos de que los datos se escriban de inmediato en el archivo, ya luego cerramos el BufferedWriter con close() y así liberamos los recursos.
Ejemplo 2: Escribe múltiples líneas en un archivo
En esa ocasión vas a suponer que tienes una lista de elementos que deseas escribir en un archivo, cada uno en una línea diferente. Hazlo con BufferedWriter en Java, utilizando un bucle.
import java.io.*;
public class EscribirVariasLineas {
public static void main(String[] args) {
String[] lineas = {"Línea 1", "Línea 2", "Línea 3", "Línea 4"};
try {
FileWriter archivo = new FileWriter("variasLineas.txt");
BufferedWriter escritor = new BufferedWriter(archivo);
for (String linea : lineas) {
escritor.write(linea);
escritor.newLine(); // Añadimos una nueva línea después de cada texto
}
escritor.flush(); // Aseguramos que todo se haya escrito
escritor.close(); // Cerramos el BufferedWriter
System.out.println("¡Archivo con varias líneas escrito con éxito!");
} catch (IOException e) {
e.printStackTrace();
}
}
}
Aquí te mostré cómo escribir varias líneas en un archivo, usando un arreglo de cadenas. Entonces, cada que escribas una cadena, usa newLine() para que te asegures de que se añada a una nueva línea después de cada texto.
Ejemplo 3: Escribe en la consola y en un archivo simultáneamente
Para este tercer ejemplo vas a suponer que quieres capturar la entrada del usuario desde la consola y escribir esa entrada en un archivo. Te recomiendo hacerlo así:
import java.io.*;
public class LeerYEscribirConsolaArchivo {
public static void main(String[] args) {
try {
// Leer desde la consola
BufferedReader consola = new BufferedReader(new InputStreamReader(System.in));
FileWriter archivo = new FileWriter("entradaConsola.txt");
BufferedWriter archivoEscribir = new BufferedWriter(archivo);
String linea;
System.out.println("Escribe algo (escribe 'exit' para terminar):");
while (!(linea = consola.readLine()).equals("exit")) {
archivoEscribir.write(linea);
archivoEscribir.newLine(); // Añadir una nueva línea
}
consola.close();
archivoEscribir.close();
System.out.println("¡Datos escritos en el archivo!");
} catch (IOException e) {
e.printStackTrace();
}
}
}
Si te diste cuenta, aquí se lee la entrada del usuario desde la consola y se escribe en el archivo entradaConsola.txt. El programa continuará ejecutándose hasta que el usuario ingrese “exit”, momento en el cual se cierra el flujo de lectura y escritura.
Usa BufferedWriter en Java correctamente con estos consejos
- Usa flush() para forzar la escritura: Con flush() te asegurarás de que los datos se escriban de inmediato, especialmente si necesitas que los cambios se guarden de forma rápida.
- Gestiona bien los recursos: Recuerda siempre cerrar el BufferedWriter en Java cuando termines de usarlo, utilizando el método close(). Esto libera los recursos asociados y asegura que los datos se escriban correctamente.
- Evita escribir demasiado a menudo: Si tienes que escribir en un archivo en múltiples ocasiones en un bucle, es más eficiente usar un solo BufferedWriter en lugar de abrir y cerrar el flujo constantemente.
Aprende a programar con Java y conviértete en un experto en desarrollo Full Stack, uniéndote al Bootcamp de Java Full Stack de KeepCoding. Te enseñaré desde lo más básico hasta lo más avanzado, en un entorno dinámico y lleno de desafíos reales. ¡Este es tu momento!
