Java: Entrada y salida IO

Entrada y salida IO en Java

La entrada y salida (Input/Output o IO) constituye uno de los pilares fundamentales en cualquier aplicación Java. Permite que nuestros programas interactúen con el mundo exterior, ya sea leyendo datos del usuario, procesando archivos o comunicándose con otros sistemas.

Java proporciona un ecosistema robusto de clases y métodos para manejar operaciones de IO de manera eficiente y segura. Estas herramientas nos permiten crear aplicaciones interactivas que pueden procesar información de múltiples fuentes y generar resultados útiles.

Fundamentos de IO en Java

El paquete java.io contiene las clases principales para realizar operaciones de entrada y salida. Este paquete incluye desde las clases más básicas para leer texto hasta herramientas avanzadas para manipular archivos binarios.

Las operaciones de IO en Java se basan en el concepto de streams (flujos de datos). Un stream es una secuencia de datos que puede leerse o escribirse de forma secuencial. Existen dos tipos principales:

• Streams de entrada: Para leer datos desde una fuente
• Streams de salida: Para escribir datos hacia un destino

Entrada de datos desde consola

La forma más común de obtener entrada del usuario es a través de la consola. Java ofrece varias aproximaciones para esta tarea, siendo Scanner la más utilizada por su simplicidad y versatilidad.

import java.util.Scanner;

Scanner scanner = new Scanner(System.in);
System.out.print("Introduce tu nombre: ");
String nombre = scanner.nextLine();
System.out.println("Hola, " + nombre);

La clase Scanner puede leer diferentes tipos de datos utilizando métodos específicos como nextInt(), nextDouble(), nextBoolean(), cada uno diseñado para procesar el tipo de dato correspondiente.

Salida de datos a consola

Para mostrar información al usuario, Java proporciona principalmente dos métodos a través de System.out:

// Imprime sin salto de línea
System.out.print("Texto sin salto de línea");

// Imprime con salto de línea automático
System.out.println("Texto con salto de línea");

// Imprime con formato específico
System.out.printf("El precio es: %.2f euros%n", 25.99);

El método printf permite formatear la salida de manera precisa, controlando aspectos como el número de decimales, el ancho de campo y la alineación del texto.

Manejo de archivos de texto

El procesamiento de archivos es esencial en aplicaciones reales. Java facilita la lectura y escritura de archivos de texto mediante clases especializadas.

Lectura de archivos:

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

try (BufferedReader reader = new BufferedReader(new FileReader("datos.txt"))) {
    String linea;
    while ((linea = reader.readLine()) != null) {
        System.out.println(linea);
    }
} catch (IOException e) {
    System.err.println("Error al leer el archivo: " + e.getMessage());
}

Escritura de archivos:

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

try (BufferedWriter writer = new BufferedWriter(new FileWriter("salida.txt"))) {
    writer.write("Primera línea de texto");
    writer.newLine();
    writer.write("Segunda línea de texto");
} catch (IOException e) {
    System.err.println("Error al escribir el archivo: " + e.getMessage());
}

Gestión de excepciones en operaciones IO

Las operaciones de entrada y salida pueden fallar por diversos motivos: archivos inexistentes, permisos insuficientes o problemas de conectividad. Java maneja estas situaciones mediante excepciones específicas.

La IOException es la excepción base para problemas de IO. Es una excepción verificada, lo que significa que debemos manejarla explícitamente usando bloques try-catch o declarándola en la signatura del método.

public void procesarArchivo(String nombreArchivo) throws IOException {
    BufferedReader reader = new BufferedReader(new FileReader(nombreArchivo));
    // Procesamiento del archivo
    reader.close(); // Importante cerrar recursos
}

Try-with-resources

Java 7 introdujo la construcción try-with-resources, que simplifica significativamente el manejo de recursos que deben cerrarse después de su uso:

try (Scanner scanner = new Scanner(new File("datos.txt"))) {
    while (scanner.hasNextLine()) {
        String linea = scanner.nextLine();
        // Procesar línea
    }
} // El scanner se cierra automáticamente

Esta construcción garantiza que los recursos se cierren automáticamente, incluso si ocurre una excepción durante el procesamiento.

Validación de entrada

En aplicaciones reales, es crucial validar los datos que introduce el usuario para evitar errores y comportamientos inesperados:

Scanner scanner = new Scanner(System.in);
int edad = -1;

while (edad < 0 || edad > 150) {
    System.out.print("Introduce tu edad (0-150): ");
    if (scanner.hasNextInt()) {
        edad = scanner.nextInt();
        if (edad < 0 || edad > 150) {
            System.out.println("Edad no válida. Inténtalo de nuevo.");
        }
    } else {
        System.out.println("Por favor, introduce un número válido.");
        scanner.next(); // Limpiar entrada inválida
    }
}

Esta aproximación asegura que el programa maneje correctamente entradas incorrectas sin terminar abruptamente.