Título: Manejo de Flujos de Caracteres en Java

Introducción

El manejo de ficheros en Java es una habilidad esencial para cualquier desarrollador. En este artículo exploraremos cómo trabajar con flujos de caracteres utilizando diversas clases del paquete java.io. Estas clases permiten realizar operaciones de entrada y salida (E/S) de datos, y son fundamentales para la lectura y escritura de ficheros de texto. A lo largo del artículo, explicaremos cómo utilizar clases como FileReader, FileWriter, BufferedReader, BufferedWriter, entre otras, con ejemplos prácticos que ilustran su uso.

Flujos de caracteres en Java

En Java, los flujos de caracteres trabajan con datos de 16 bits (Unicode), lo que permite la internacionalización y la manipulación eficiente de texto. Las clases principales para este propósito son:

• Reader y Writer: Clases abstractas que proporcionan métodos para la lectura y escritura de caracteres.
• FileReader y FileWriter: Clases específicas para la lectura y escritura de ficheros de texto.
• BufferedReader y BufferedWriter: Clases que optimizan el acceso a ficheros mediante un buffer intermedio, lo que mejora la eficiencia.
• CharArrayReader y CharArrayWriter: Permiten la lectura y escritura en arrays de caracteres.

Lectura de ficheros con FileReader y BufferedReader

La clase FileReader representa un flujo de entrada hacia un fichero y permite leer caracteres uno a uno o en bloques. Por otro lado, BufferedReader facilita la lectura de líneas completas y utiliza un buffer intermedio para mejorar el rendimiento.

Ejemplo 1: Leer un fichero de texto con FileReader

import java.io.FileReader;
import java.io.IOException;

public class LeerFicheroTexto {
    public static void main(String[] args) {
        try {
            FileReader lector = new FileReader("archivo.txt");
            int caracter;
            // Leemos carácter por carácter hasta el final del fichero
            while ((caracter = lector.read()) != -1) {
                System.out.print((char) caracter);
            }
            lector.close();
        } catch (IOException e) {
            System.out.println("Error al leer el fichero: " + e.getMessage());
        }
    }
}

Explicación del código:

• FileReader lector = new FileReader("archivo.txt");: Se abre el fichero «archivo.txt» para leerlo.
• lector.read(): Se lee un carácter a la vez hasta que -1 indica el final del fichero.
• El flujo se cierra con lector.close().

Ejemplo 2: Leer un fichero línea por línea con BufferedReader

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class LeerConBuffer {
    public static void main(String[] args) {
        try {
            BufferedReader buffer = new BufferedReader(new FileReader("archivo.txt"));
            String linea;
            // Leemos línea por línea hasta el final del fichero
            while ((linea = buffer.readLine()) != null) {
                System.out.println(linea);
            }
            buffer.close();
        } catch (IOException e) {
            System.out.println("Error al leer el fichero: " + e.getMessage());
        }
    }
}

Explicación del código:

• BufferedReader buffer = new BufferedReader(new FileReader("archivo.txt"));: Se utiliza un buffer para leer el fichero.
• buffer.readLine(): Este método lee una línea completa en lugar de un solo carácter.
• El flujo se cierra con buffer.close().

Escritura de ficheros con FileWriter y BufferedWriter

De manera similar a la lectura, la escritura de ficheros también puede realizarse con flujos de caracteres. FileWriter permite escribir caracteres en un fichero, mientras que BufferedWriter optimiza el proceso usando un buffer.

Ejemplo 3: Escribir en un fichero con FileWriter

import java.io.FileWriter;
import java.io.IOException;

public class EscribirFichero {
    public static void main(String[] args) {
        try {
            FileWriter escritor = new FileWriter("archivo.txt");
            escritor.write("Este es un ejemplo de escritura en un fichero.\n");
            escritor.write("Agregamos otra línea de texto.");
            escritor.close();
        } catch (IOException e) {
            System.out.println("Error al escribir en el fichero: " + e.getMessage());
        }
    }
}

Explicación del código:

• FileWriter escritor = new FileWriter("archivo.txt");: Crea un nuevo fichero o sobrescribe uno existente.
• escritor.write(): Escribe el contenido en el fichero.
• El flujo se cierra con escritor.close().

Ejemplo 4: Escribir en un fichero usando BufferedWriter

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class EscribirConBuffer {
    public static void main(String[] args) {
        try {
            BufferedWriter buffer = new BufferedWriter(new FileWriter("archivo.txt", true));
            buffer.write("Este es un ejemplo usando BufferedWriter.\n");
            buffer.newLine();  // Añade un salto de línea
            buffer.write("Agregamos otra línea con un buffer.");
            buffer.close();
        } catch (IOException e) {
            System.out.println("Error al escribir en el fichero: " + e.getMessage());
        }
    }
}

Explicación del código:

• BufferedWriter buffer = new BufferedWriter(new FileWriter("archivo.txt", true));: Crea o abre el fichero en modo de anexado (true).
• buffer.newLine(): Añade un salto de línea.
• El flujo se cierra con buffer.close().

Manejo de Excepciones

Todas las operaciones de E/S en Java pueden lanzar excepciones, como IOException o FileNotFoundException. Es importante manejar estas excepciones para asegurarse de que el programa responda adecuadamente ante errores, como la ausencia de un fichero o problemas al escribir en un disco lleno.

Conclusión

Trabajar con flujos de caracteres en Java es fundamental para leer y escribir ficheros de texto de manera eficiente. Utilizando clases como FileReader, FileWriter, BufferedReader, y BufferedWriter, podemos implementar soluciones eficaces para manejar ficheros en nuestras aplicaciones. Los ejemplos prácticos presentados en este artículo son una base sólida para comenzar a trabajar con ficheros en Java, y el uso de buffers optimiza el rendimiento en aplicaciones que requieren acceso frecuente a datos.