Manipulación de archivos en Java

Introducción a la manipulación de archivos en Java

La gestión de archivos constituye una de las tareas fundamentales en el desarrollo de aplicaciones con Java, ya que permite la persistencia de datos, la lectura y escritura de información, así como la interacción con el sistema de archivos del entorno operativo. Desde la simple lectura de un archivo de texto hasta operaciones más complejas como la serialización de objetos o la manipulación de directorios, Java ofrece un conjunto robusto de clases y métodos que facilitan estas tareas de manera eficiente y segura.

En este artículo, publicado en Revista Completa, se abordará en profundidad la manipulación de archivos en Java, explorando desde las clases básicas hasta técnicas avanzadas. Se explicarán conceptos esenciales, se proporcionarán ejemplos prácticos y se analizarán las mejores prácticas para garantizar la integridad, eficiencia y seguridad en las operaciones con archivos.

Clases fundamentales para trabajar con archivos en Java

La clase File: representación y gestión básica

La clase java.io.File es la piedra angular para interactuar con archivos y directorios en Java. Esta clase permite representar de manera abstracta el nombre, la ruta, y el estado de un archivo o directorio en el sistema de archivos. Además, proporciona métodos para crear, eliminar, verificar existencia, obtener información y listar contenidos de directorios.

Por ejemplo, para verificar si un archivo o directorio existe, se emplea el método exists(). Para crear un archivo o directorio, se utilizan createNewFile() y mkdir(), respectivamente. La eliminación se realiza mediante delete().

Ejemplo básico de uso de la clase File

File archivo = new File("ejemplo.txt");
if (archivo.exists()) { ... }

File nuevoArchivo = new File("nuevo.txt");
if (nuevoArchivo.createNewFile()) { ... }

File archivoAEliminar = new File("eliminar.txt");
if (archivoAEliminar.delete()) { ... }

File directorio = new File("miDirectorio");
File[] archivos = directorio.listFiles();

Operaciones avanzadas con archivos

Además de la gestión básica, la clase File permite realizar operaciones más sofisticadas, como crear enlaces simbólicos, obtener atributos del archivo (como tamaño, fecha de modificación, permisos), y modificar los atributos cuando sea necesario. La gestión de permisos es especialmente importante en entornos multiusuario, donde la seguridad y el control de acceso son prioritarios.

Lectura de archivos en Java

Clases para la lectura: FileInputStream, BufferedReader y Scanner

Para leer archivos en Java, existen varias clases, cada una adecuada para diferentes contextos. La más básica, FileInputStream, permite leer bytes de un archivo y es útil para archivos binarios o cuando se requiere control sobre la lectura a nivel byte.

Para la lectura de archivos de texto línea por línea, las clases BufferedReader y Scanner son las más utilizadas. La primera, envolviendo un FileReader, proporciona una lectura eficiente y conveniente, mientras que Scanner permite también parsear datos con facilidad.

Ejemplo de lectura línea por línea con BufferedReader

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

public class LeerArchivoLinea {
    public static void main(String[] args) {
        File archivo = new File("texto.txt");
        try (BufferedReader br = new BufferedReader(new FileReader(archivo))) {
            String linea;
            while ((linea = br.readLine()) != null) {
                System.out.println(linea);
            }
        } catch (IOException e) {
            System.out.println("Error al leer el archivo: " + e.getMessage());
        }
    }
}

Este ejemplo muestra cómo abrir un archivo de texto, leerlo línea por línea y mostrar su contenido en consola. La estructura try-with-resources garantiza el cierre automático del recurso, promoviendo buenas prácticas en la gestión de recursos.

Ejemplo con Scanner

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class LeerConScanner {
    public static void main(String[] args) {
        try (Scanner sc = new Scanner(new File("texto.txt"))) {
            while (sc.hasNextLine()) {
                System.out.println(sc.nextLine());
            }
        } catch (FileNotFoundException e) {
            System.out.println("Archivo no encontrado: " + e.getMessage());
        }
    }
}

Importancia del manejo de excepciones y cierre de recursos

Siempre que se trabaja con archivos, es imprescindible gestionar adecuadamente las excepciones, ya que operaciones como apertura, lectura o escritura pueden fallar por motivos diversos (archivo inexistente, permisos insuficientes, errores de entrada/salida). Además, el cierre correcto de los recursos evita fugas de memoria y bloqueos en el sistema operativo.

Escritura en archivos en Java

Clases para escribir: FileWriter, BufferedWriter y PrintWriter

Para escribir en archivos, Java proporciona varias clases. La más elemental, FileWriter, permite escribir caracteres en un archivo, pero puede ser ineficiente si se realiza muchas escrituras pequeñas. Para solucionar este problema, se utilizan BufferedWriter y PrintWriter, que ofrecen métodos convenientes para escribir líneas completas o datos formateados.

Ejemplo básico de escritura con BufferedWriter

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

public class EscribirArchivo {
    public static void main(String[] args) {
        File archivo = new File("salida.txt");
        try (BufferedWriter bw = new BufferedWriter(new FileWriter(archivo))) {
            bw.write("¡Hola, mundo!");
            bw.newLine();
            bw.write("Este es un ejemplo de escritura en Java.");
        } catch (IOException e) {
            System.out.println("Error al escribir en el archivo: " + e.getMessage());
        }
    }
}

Este ejemplo crea o sobreescribe un archivo llamado «salida.txt» y escribe en él dos líneas de texto. La utilización del bloque try-with-resources asegura que el buffer se vacíe y los recursos se liberen apropiadamente.

Ejemplo con PrintWriter para formateo de datos

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;

public class EscribirFormateado {
    public static void main(String[] args) {
        try (PrintWriter pw = new PrintWriter(new File("datos.txt"))) {
            pw.printf("Nombre: %s%nEdad: %d%n", "Juan Pérez", 30);
        } catch (FileNotFoundException e) {
            System.out.println("No se pudo crear el archivo: " + e.getMessage());
        }
    }
}

Serialización de objetos: guardar y recuperar estados completos

Una de las funcionalidades más potentes de Java en el manejo de archivos es la serialización, que permite guardar el estado completo de un objeto en un archivo y posteriormente recuperarlo, restaurando su estado original. Para ello, las clases deben implementar la interfaz Serializable.

Ejemplo de serialización y deserialización

import java.io.*;

class Persona implements Serializable {
    private static final long serialVersionUID = 1L;
    String nombre;
    int edad;

    public Persona(String nombre, int edad) {
        this.nombre = nombre;
        this.edad = edad;
    }
}

public class SerializarPersona {
    public static void main(String[] args) {
        Persona p = new Persona("Ana López", 28);
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("persona.ser"))) {
            oos.writeObject(p);
            System.out.println("Objeto serializado correctamente.");
        } catch (IOException e) {
            System.out.println("Error en serialización: " + e.getMessage());
        }

        // Para recuperar el objeto
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("persona.ser"))) {
            Persona pRecuperada = (Persona) ois.readObject();
            System.out.println("Nombre: " + pRecuperada.nombre);
            System.out.println("Edad: " + pRecuperada.edad);
        } catch (IOException | ClassNotFoundException e) {
            System.out.println("Error en deserialización: " + e.getMessage());
        }
    }
}

Este proceso es esencial en aplicaciones que necesitan persistir objetos complejos, como en sistemas de almacenamiento, caching o comunicación remota.

Operaciones con archivos y directorios: verificación, creación, eliminación y listado

Verificación y creación de archivos y directorios

El método exists() permite determinar si un archivo o directorio existe, mientras que createNewFile() y mkdir() sirven para crear nuevos archivos o directorios, respectivamente. La creación condicional es útil para evitar sobrescribir recursos existentes.

Eliminar archivos y directorios

La eliminación se realiza mediante delete()

import java.io.File;

public class ListarContenido {
    public static void main(String[] args) {
        File directorio = new File("miDirectorio");
        if (directorio.isDirectory()) {
            File[] archivos = directorio.listFiles();
            System.out.println("Contenido del directorio:");
            for (File archivo : archivos) {
                System.out.println(archivo.getName() + (archivo.isDirectory() ? " (Directorio)" : " (Archivo)"));
            }
        } else {
            System.out.println("La ruta especificada no es un directorio.");
        }
    }
}

import java.nio.file.*;

public class GestionNIO {
    public static void main(String[] args) {
        Path ruta = Paths.get("ejemplo.txt");
        if (Files.exists(ruta)) {
            System.out.println("El archivo existe en: " + ruta.toAbsolutePath());
        } else {
            try {
                Files.createFile(ruta);
                System.out.println("Archivo creado en: " + ruta.toAbsolutePath());
            } catch (IOException e) {
                System.out.println("Error al crear el archivo: " + e.getMessage());
            }
        }

        // Listar contenidos de un directorio
        Path directorio = Paths.get("otraCarpeta");
        try (DirectoryStream stream = Files.newDirectoryStream(directorio)) {
            System.out.println("Contenido del directorio:");
            for (Path p : stream) {
                System.out.println(p.getFileName());
            }
        } catch (IOException e) {
            System.out.println("Error al listar directorio: " + e.getMessage());
        }
    }
}