En programación, es común necesitar leer y escribir archivos de texto para almacenar o recuperar información. Java proporciona varias clases y métodos para realizar estas operaciones de manera eficiente. En esta guía, exploraremos cómo trabajar con archivos en Java 1.8, centrándonos en la lectura y escritura de archivos de texto. Para ello utilizaremos las clases más importantes y veremos ejemplos prácticos y detallados.

¿Por qué es importante manejar archivos de texto?

Los archivos de texto son una forma sencilla y universal de almacenar datos. Algunas aplicaciones comunes incluyen:

• Guardar configuraciones o preferencias del usuario.
• Almacenar datos para su posterior análisis.
• Importar o exportar información entre sistemas.

Conceptos Básicos

Antes de sumergirnos en el código, es importante entender algunos conceptos clave:

• Flujos (Streams): En Java, un flujo es una secuencia de datos que se lee (flujo de entrada) o se escribe (flujo de salida). Los flujos pueden ser de bytes o de caracteres.
• Clases Principales:
  • FileReader y FileWriter: Para leer y escribir archivos de texto.
  • BufferedReader y BufferedWriter: Para leer y escribir de manera más eficiente mediante el uso de un búfer.
  • FileInputStream y FileOutputStream: Para leer y escribir archivos binarios.

Escritura de Archivos

1. Usando BufferedWriter y FileWriter

Para escribir en un archivo de texto en Java, podemos utilizar la clase FileWriter. A continuación, se muestra un ejemplo de cómo hacerlo:

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

public class EscrituraArchivo {
    public static void main(String[] args) {
        String contenido = "Hola, este es un ejemplo de escritura en un archivo.";

        try (FileWriter escritor = new FileWriter("ejemplo.txt")) {
            escritor.write(contenido);
            System.out.println("Archivo escrito exitosamente.");
        } catch (IOException e) {
            System.out.println("Ocurrió un error al escribir en el archivo.");
            e.printStackTrace();
        }
    }
}

Explicación del Código:

• Importación de Clases Necesarias: Se importa FileWriter para la escritura de archivos y IOException para manejar posibles excepciones.
• Definición de la Clase y Método Principal: La clase EscrituraArchivo contiene el método main, que es el punto de entrada del programa.
• Contenido a Escribir: Se define una cadena de texto llamada contenido que contiene el texto que se escribirá en el archivo.
• Bloque try-with-resources: Se utiliza esta estructura para asegurar que el recurso FileWriter se cierre automáticamente al finalizar, incluso si ocurre una excepción.
• Creación del FileWriter: Se crea una instancia de FileWriter que apunta al archivo ejemplo.txt. Si el archivo no existe, se crea automáticamente.
• Escritura en el Archivo: Se utiliza el método write para escribir el contenido en el archivo.
• Manejo de Excepciones: Si ocurre una excepción durante la escritura, se captura y se imprime un mensaje de error.

2. Usando Files.write()

Este método escribe una lista de cadenas en un archivo.

import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.List;

public class EscrituraArchivo {
    public static void main(String[] args) {
        try {
            // Crear una lista de líneas
            List<String> lineas = Arrays.asList("Línea 1", "Línea 2", "Línea 3");

            // Escribir las líneas en el archivo
            Files.write(Paths.get("archivo_salida.txt"), lineas);

            System.out.println("Archivo escrito correctamente.");
        } catch (Exception e) {
            System.out.println("Error al escribir el archivo: " + e.getMessage());
        }
    }
}

Explicación del código:

• Arrays.asList() crea una lista de cadenas.
• Files.write() escribe la lista en el archivo. Si el archivo no existe, lo crea.

3. Usando BufferedWriter

BufferedWriter es más eficiente para escribir archivos grandes o cuando se necesita escribir línea por línea.

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

public class EscrituraBufferedWriter {
    public static void main(String[] args) {
        try (BufferedWriter bw = Files.newBufferedWriter(Paths.get("archivo_salida.txt"))) {
            // Escribir líneas en el archivo
            bw.write("Línea 1");
            bw.newLine();
            bw.write("Línea 2");
            bw.newLine();
            bw.write("Línea 3");

            System.out.println("Archivo escrito correctamente.");
        } catch (Exception e) {
            System.out.println("Error al escribir el archivo: " + e.getMessage());
        }
    }
}

Explicación del código:

• Files.newBufferedWriter() crea un BufferedWriter para escribir en el archivo.
• write() escribe una cadena en el archivo.
• newLine() añade una nueva línea.
• El bloque try-with-resources asegura que el BufferedWriter se cierre automáticamente.

Lectura de Archivos

1. Usando Files.readAllLines()

Este método lee todas las líneas de un archivo y las devuelve como una lista de cadenas (List<String>).

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

public class LecturaArchivo {
    public static void main(String[] args) {
        try {
            // Leer todas las líneas del archivo
            List<String> lineas = Files.readAllLines(Paths.get("archivo.txt"));

            // Mostrar cada línea
            for (String linea : lineas) {
                System.out.println(linea);
            }
        } catch (Exception e) {
            System.out.println("Error al leer el archivo: " + e.getMessage());
        }
    }
}

Explicación del código:

• Paths.get("archivo.txt") crea un objeto Path que representa la ruta del archivo.
• Files.readAllLines() lee todas las líneas del archivo y las almacena en una lista.
• Se recorre la lista para mostrar cada línea.

2. Usando BufferedReader

BufferedReader es más eficiente para leer archivos grandes, ya que lee el archivo línea por línea.

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

public class LecturaBufferedReader {
    public static void main(String[] args) {
        try (BufferedReader br = Files.newBufferedReader(Paths.get("archivo.txt"))) {
            String linea;
            // Leer línea por línea
            while ((linea = br.readLine()) != null) {
                System.out.println(linea);
            }
        } catch (Exception e) {
            System.out.println("Error al leer el archivo: " + e.getMessage());
        }
    }
}

Explicación del código:

• Files.newBufferedReader() crea un BufferedReader para leer el archivo.
• readLine() lee una línea del archivo. Si no hay más líneas, devuelve null.
• El bloque try-with-resources asegura que el BufferedReader se cierre automáticamente.

Explicación del código:

• Files.newBufferedReader() crea un BufferedReader para leer el archivo.
• readLine() lee una línea del archivo. Si no hay más líneas, devuelve null.
• El bloque try-with-resources asegura que el BufferedReader se cierre automáticamente.

3. Usando BufferedReader y FileReader

Para leer un archivo de texto, podemos utilizar la clase FileReader junto con BufferedReader para una lectura más eficiente. A continuación, se muestra un ejemplo:

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

public class LecturaArchivo {
    public static void main(String[] args) {
        try (BufferedReader lector = new BufferedReader(new FileReader("ejemplo.txt"))) {
            String linea;
            while ((linea = lector.readLine()) != null) {
                System.out.println(linea);
            }
        } catch (IOException e) {
            System.out.println("Ocurrió un error al leer el archivo.");
            e.printStackTrace();
        }
    }
}

Explicación del Código:

• Importación de Clases Necesarias: Se importan BufferedReader, FileReader e IOException.
• Definición de la Clase y Método Principal: La clase LecturaArchivo contiene el método main.
• Bloque try-with-resources: Se utiliza para asegurar el cierre automático del BufferedReader.
• Creación del BufferedReader: Se crea una instancia de BufferedReader que envuelve a un FileReader apuntando al archivo ejemplo.txt.
• Lectura del Archivo: Se lee el archivo línea por línea utilizando un bucle while y el método readLine. Cada línea leída se imprime en la consola.
• Manejo de Excepciones: Si ocurre una excepción durante la lectura, se captura y se imprime un mensaje de error.

Consideraciones

Hasta ahora hemos declarado BufferedReader y BufferedWriter usando Files.newBufferedReader() y Files.newBufferedWriter(). Esto tiene ventajas en cuanto a facilidad y legibilidad, pero tiene también sus limitaciones. Se puede hacer de otra forma más tradicional si necesitas por ejemplo controlar la codificación de los archivos. Ambas formas son válidas, pero la primera es más conveniente y recomendable en Java 1.8 y versiones posteriores. A continuación, te explico en detalle las diferencias:

Forma tradicional

La forma tradicional de declarar un BufferedReader sería:

BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("archivo.txt")));
BufferedWriter br = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("archivo.txt")));

Ventajas:

• Control más granular: Puedes especificar manualmente la codificación del archivo al crear el InputStreamReader, lo que es útil si el archivo no usa la codificación por defecto (UTF-8).

• Compatibilidad con versiones antiguas: Este enfoque funciona en versiones de Java anteriores a 1.7 (antes de la introducción de Files y Paths).

Desventajas:

• Código más verboso: requiere encadenar múltiples constructores, lo que hace el código más difícil de leer y mantener.
• Manejo manual de recursos: Si no usas try-with-resources, debes cerrar manualmente el BufferedReader o BufferedWriter, lo que puede llevar a fugas de recursos si no se hace correctamente. Lo comprobarás en el ejemplo. La suerte es que puedes incluir la declaración en un try-with-resources.
• Mayor complejidad: Hay más pasos involucrados, lo que aumenta la probabilidad de errores, como olvidar cerrar un recurso o usar una codificación incorrecta.

Ejemplo:

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;

public class EjemploTraditional {
    public static void main(String[] args) {
        BufferedReader br = null;
        try {
            br = new BufferedReader(new InputStreamReader(new FileInputStream("archivo.txt")));
            String linea;
            while ((linea = br.readLine()) != null) {
                System.out.println(linea);
            }
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        } finally {
            try {
                if (br != null) br.close(); // Cerrar manualmente
            } catch (Exception e) {
                System.out.println("Error al cerrar el archivo: " + e.getMessage());
            }
        }
    }
}

Files.newBufferedReader() y Files.newBufferedWriter()

Ventajas:

• Código más simple y legible:
  • La clase Files proporciona métodos estáticos que simplifican la creación de BufferedReader y BufferedWriter.
  • No es necesario encadenar múltiples constructores (FileInputStream, InputStreamReader, etc.).
• Manejo automático de recursos:
  • Al usar try-with-resources, no necesitas cerrar manualmente el BufferedReader o BufferedWriter. Java se encarga de cerrar los recursos automáticamente.
• Compatibilidad con Path:
  • Files.newBufferedReader() y Files.newBufferedWriter() trabajan directamente con objetos Path, que son más modernos y flexibles que las cadenas de rutas de archivo.
• Menos propenso a errores:
  • Al reducir la cantidad de pasos y clases involucradas, hay menos posibilidades de cometer errores, como olvidar cerrar un recurso o usar una codificación incorrecta.

Ejemplo:

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

public class EjemploFiles {
    public static void main(String[] args) {
        try (BufferedReader br = Files.newBufferedReader(Paths.get("archivo.txt"))) {
            String linea;
            while ((linea = br.readLine()) != null) {
                System.out.println(linea);
            }
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

Comparación Detallada

¿Cuándo usar cada enfoque?

Usa Files.newBufferedReader() y Files.newBufferedWriter():

• Si estás trabajando con Java 1.7 o posterior.
• Si prefieres un código más simple y legible.
• Si no necesitas especificar una codificación personalizada.

Usa new BufferedReader(new InputStreamReader(...)):

• Si estás trabajando con una versión de Java anterior a 1.7.
• Si necesitas especificar una codificación de archivo diferente a UTF-8.
• Si requieres un control más granular sobre el flujo de entrada/salida.

¿Usamos finally?

Es altamente recomendable cerrar los búferes y archivos al finalizar su uso para liberar los recursos asociados y evitar posibles fugas de memoria. En Java, esto se puede lograr de manera efectiva utilizando un bloque finally o, a partir de Java 7, mediante la estructura try-with-resources.

Uso del bloque finally para cerrar recursos:

El bloque finally se ejecuta siempre, independientemente de si se lanza o no una excepción en el bloque try. Esto lo convierte en un lugar ideal para cerrar recursos como búferes o archivos.

En este ejemplo, el bloque finally asegura que el BufferedReader se cierre correctamente, incluso si ocurre una excepción durante las operaciones de lectura.

Uso de try-with-resources:

A partir de Java 7, se introdujo la estructura try-with-resources, que simplifica la gestión de recursos. Esta estructura cierra automáticamente los recursos al finalizar el bloque try, sin necesidad de un bloque finally.

En este caso, el BufferedReader se declara dentro de los paréntesis del try. Al finalizar el bloque try, ya sea de manera normal o debido a una excepción, el recurso se cierra automáticamente. Esto reduce la complejidad del código y minimiza el riesgo de olvidar cerrar un recurso.

En resumen, es una buena práctica cerrar siempre los búferes y archivos al terminar su uso. Puedes hacerlo manualmente en un bloque finally o aprovechar la estructura try-with-resources para una gestión más sencilla y segura de los recursos.

Buenas prácticas

• Cierre de Recursos: Utilizar try-with-resources es una práctica recomendada para asegurar que los recursos se cierren correctamente y evitar posibles fugas de memoria.
• Maneja excepciones: Siempre captura y maneja excepciones al trabajar con archivos. Es crucial para evitar que el programa falle inesperadamente. Las clases de E/S pueden lanzar excepciones que deben ser capturadas o declaradas.
• Elige el método adecuado: Usa Files.readAllLines() para archivos pequeños y BufferedReader para archivos grandes.
• Verifica la existencia del archivo: Antes de leer o escribir, verifica si el archivo existe usando Files.exists().
• Codificación de Caracteres: Al leer o escribir archivos de texto, es importante considerar la codificación de caracteres para asegurar que los datos se interpreten correctamente.

Ejercicios Propuestos

1. Escribe un programa que lea un archivo de texto y cuente el número de líneas.
2. Crea un programa que copie el contenido de un archivo de texto en otro archivo.
3. Desarrolla una aplicación que lea un archivo de texto, modifique su contenido (por ejemplo, convirtiendo todo a mayúsculas) y lo guarde en un nuevo archivo.

Conclusión

El manejo de archivos en Java es una habilidad esencial que permite a los programadores interactuar con el sistema de archivos para leer y escribir datos de manera eficiente. Al comprender y utilizar las clases y métodos adecuados, se pueden realizar operaciones de E/S de manera efectiva y segura.

La lectura y escritura de archivos de texto son operaciones fundamentales en Java. Con las herramientas proporcionadas por Java 1.8, como Files, BufferedReader, y BufferedWriter, puedes manejar archivos de manera eficiente y segura. Practica con los ejemplos y ejercicios propuestos para dominar estas técnicas.