Java I/O: Lectura y Escritura de Ficheros con BufferedReader, FileReader, FileWriter y RandomAccessFile

Manejo de ficheros en Java con BufferedReader, BufferedWriter, FileReader, FileWriter y RandomAccessFile

A continuación se presentan ejemplos prácticos de entrada y salida (I/O) en Java, con sus respectivos mecanismos de manejo de excepciones.

1. Lectura con BufferedReader

Importamos las librerías de BufferedReader, FileReader y su manejo de excepciones:

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

public class EjemploBufferedReader {
    public static void main(String[] args) {
        // Variable para almacenar la línea leída
        String linea;
        // Contador de líneas
        int numLinea = 1;

        try (BufferedReader br =
                 new BufferedReader(new FileReader("src/AccesoFicherosIO/entrada_buffered.txt"))) {

            // readLine() retorna null cuando no hay más líneas
            while ((linea = br.readLine()) != null) {
                System.out.println(numLinea + ": " + linea);
                numLinea++;
            }

        } catch (IOException e) {
            System.err.println("Error al cargar el archivo: " + e.getMessage());
        }
    }
}

2. Escritura con BufferedWriter

Importamos las librerías de BufferedWriter, FileWriter y su manejo de excepciones:

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

public class EjemploBufferedWriter {
    public static void main(String[] args) {
        // Array con líneas a escribir
        String[] lineas = {
                "Encabezado del documento",
                "Esta es la primera línea del documento",
                "Esta es la segunda línea",
                "Final del documento"
        };

        // BufferedWriter envuelve al objeto FileWriter para añadir
        // buffering
        try (BufferedWriter bw =
                 new BufferedWriter(new FileWriter("src/AccesoFicherosIO/entrada_buffered.txt"))) {

            for (String linea : lineas) {
                // Escritura en el documento
                bw.write(linea);
                // Salto de línea
                bw.newLine();
            }
            // flush() se llama automáticamente al final
        } catch (IOException e) {
            System.err.println("Error al escribir en el archivo: " + e.getMessage());
        }
        // Resultado esperado:
    }
}

3. Lectura carácter a carácter con FileReader

Importamos FileReader y su manejo de excepciones:

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

public class EjemploFileReader {
    public static void main(String[] args) {
        // Variable para almacenar el carácter leído
        int caracter;
        try (FileReader fr = new FileReader("src/AccesoFicherosIO/entrada.txt/entrada.txt")) {
            // read() retorna -1 cuando llega al final del archivo
            while ((caracter = fr.read()) != -1) {
                // Convertimos int en char para mostrar el carácter
                System.out.print((char) caracter);
            }

        } catch (IOException e) {
            System.out.print("Error al cargar el archivo: " + e.getMessage());
        }

        // Resultado esperado: imprime el contenido del archivo carácter a carácter
    }
}

4. Escritura con FileWriter

Importamos FileWriter y su manejo de excepciones:

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

public class EjemploFileWriter {
    public static void main(String[] args) {

        // Contenido que queremos escribir
        String contenido = "Primera línea\nSegunda línea\nTercera línea";

        // try-with-resources cierra automáticamente el FileWriter
        // Por defecto sobrescribe el archivo si existe
        try (FileWriter fw = new FileWriter("src/AccesoFicherosIO/salida.txt")) {

            // Escribe la cadena completa
            fw.write(contenido);

            // flush() se llama automáticamente al final
        } catch (IOException e) {
            System.out.print("Error al escribir en el archivo: " + e.getMessage());
        }
    }
}

Resultado esperado: genera el archivo salida.txt con el contenido indicado.

5. Acceso aleatorio con RandomAccessFile

Importamos RandomAccessFile y su manejo de excepciones:

import java.io.IOException;
import java.io.RandomAccessFile;

public class EjemploRandomAccessFile {
    public static void main(String[] args) {
        // try-with-resources cierra automáticamente el RandomAccessFile
        try (RandomAccessFile raf =
                 new RandomAccessFile("src/AccesoFicherosIO/datos.bin", "rw")) {

            // Escribimos en diferentes posiciones
            raf.writeBytes("INICIO");

            // Nos movemos a la posición 20
            raf.seek(20);
            raf.writeBytes("MEDIO");

            // Nos movemos a la posición 40
            raf.seek(40);
            raf.writeBytes("FINAL");

            // Volver al inicio para leer
            raf.seek(0);
            System.out.println("Posición 0: " + raf.readLine());

            raf.seek(20);
            System.out.println("Posición 20: " + raf.readLine());

            raf.seek(40);
            System.out.println("Posición 40: " + raf.readLine());

            // Mostrar la longitud total del archivo
            System.out.println("Tamaño del archivo: " + raf.length() + " bytes");

        } catch (IOException e) {
            System.err.println("Error al acceder al archivo: " + e.getMessage());
        }

        // Resultado esperado: escritura y lectura en posiciones específicas del archivo
    }
}