Lecciones

En la lección revisamos la lectura línea a línea con BufferedReader y la lectura completa mediante Files.readAllLines/ Files.readString, la elección del búfer (por ejemplo, 8192 bytes), el cierre seguro de recursos con try-with-resources, así como el trabajo con codificaciones ( StandardCharsets.UTF_8). Se muestran ejemplos prácticos (recuento de líneas, búsqueda en registros, análisis de configuración) y errores típicos (por ejemplo, OutOfMemoryError al cargar archivos grandes completos).

Analizamos la diferencia entre archivos de texto y binarios, los flujos de bytes básicos InputStream/ OutputStream y sus implementaciones para archivos ( FileInputStream, FileOutputStream). Escribimos una copia con búfer, comentamos la velocidad de lectura byte a byte vs por bloques, la escritura de arrays de bytes mediante write(), los matices de try-with-resources, la elección del tamaño de búfer de 4– 16 KB, el uso seguro de readAllBytes() y los errores típicos (por ejemplo, usar FileReader/ FileWriter con datos binarios).

En la lección analizamos la E/S binaria en Java con DataInputStream y DataOutputStream: cómo escribir y leer primitivos ( int, double, boolean) y cadenas ( String) mediante los métodos writeXXX/ readXXX, por qué el orden es importante, cómo almacenar arrays, cuándo tiene sentido añadir BufferedInputStream/ BufferedOutputStream y qué errores típicos conducen a IOException o EOFException.

Analizamos la forma moderna y segura de trabajar con recursos en Java — try-with-resources: comparación con el patrón antiguo try/ catch/ finally + close(), requisitos de tipos (que implementen AutoCloseable o Closeable), la sintaxis try(...){...}, el orden de cierre, las excepciones «suprimidas» mediante getSuppressed(), ejemplos con flujos de E/S y recursos personalizados, así como consejos y errores típicos.

Explicamos qué es una codificación y por qué sin ella los textos informáticos se convierten en «mojibake». Comparamos conjuntos populares: UTF-8, Windows-1251, ASCII, Unicode/ UTF-16. Hablamos de la representación interna de las cadenas en la JVM ( String en Unicode) y de la E/S correcta: especificación explícita de la codificación mediante InputStreamReader/ OutputStreamWriter y StandardCharsets.UTF_8. Al final — ejemplos prácticos y errores típicos.

Analizamos tres codificaciones fundamentales con las que se encuentra un desarrollador Java: qué es UTF-8 (estándar para la web y la mayoría de formatos), cómo está organizado el formato interno de las cadenas en la JVM — UTF-16 (con pares sustitutos y BOM), y por qué todavía aparece ISO-8859-1. Explicamos la compatibilidad con ASCII, el tamaño en bytes por carácter y mostramos la forma correcta de trabajar con codificaciones en Java mediante StandardCharsets, Files.write, Files.readString, Paths.get. Al final — errores típicos: lectura/escritura incorrectas, codificación del sistema «por defecto», confusión entre UTF-16/ UTF-8.

Cómo evitar el «mojibake» y hacer que el texto se vea igual en todas las máquinas: analizamos la codificación del sistema ( "file.encoding"), el trabajo con Charset y las constantes de StandardCharsets, leemos/escribimos mediante Files . newBufferedReader y Files . newBufferedWriter, usamos try-with-resources, consultamos las codificaciones disponibles y seguimos las mejores prácticas (por defecto — "UTF-8"). Al final — errores típicos y cómo evitarlos.

En esta lección tratamos el «mojibake», la pérdida de caracteres ( ?), excepciones como MalformedInputException, las causas (desajuste entre Windows-1251/ UTF-8, codificación del sistema «por defecto», BOM), el diagnóstico ( file.encoding) y las mejores prácticas: especificar explícitamente el Charset, usar Files/ BufferedReader con StandardCharsets, evitar FileReader/ FileWriter, y matices para XML/ JSON y BOM.

Cómo leer correctamente texto de un archivo en una codificación y escribirlo en otra usando las clases de java.nio.file y java.io: usamos Files.newBufferedReader/ Files.newBufferedWriter o InputStreamReader/ OutputStreamWriter, indicamos el Charset necesario, aplicamos try-with-resources y evitamos las trampas de la codificación del sistema. Algoritmo paso a paso, ejemplo Windows-1251 → UTF-8, matices (BOM, archivos grandes, excepciones) y errores típicos.

Cómo está organizada la jerarquía de excepciones de E/S en Java, en qué se diferencian IOException y su descendiente FileNotFoundException, cuándo se producen y cómo manejarlas correctamente. Veremos el orden de los bloques catch, práctica con lectura/escritura de archivos, consejos de registro (logging) y una tabla breve con los errores más frecuentes. Trataremos las excepciones comprobadas (checked), las palabras clave try, catch, finally, throws y el patrón try-with-resources.

Cómo comprobar en Java si existe un archivo o una carpeta: la clase File con sus métodos exists(), isFile(), isDirectory() y el enfoque moderno de NIO mediante Path y Files — Files.exists(), Files.isRegularFile(), Files.isDirectory(). Trataremos el problema TOCTOU y por qué la comprobación no sustituye al manejo de errores: incluso después de exists() puedes obtener FileNotFoundException o AccessDeniedException, por lo que siempre utiliza bloques try y, cuando sea posible, try-with-resources. Además, práctica: leer un archivo si existe, crear un directorio con Files.createDirectory() y Files.createDirectories(), y trabajar con rutas relativas y absolutas.

Cómo reconocer archivos «corruptos» por las excepciones ( EOFException, MalformedInputException, ZipException, StreamCorruptedException), qué hacer ante un desajuste de formato y qué estrategias de recuperación utilizar: registro (logging) y notificación al usuario, lectura parcial hasta el error, copias de seguridad, sumas de verificación ( SHA-256). Práctica con la lectura hasta EOF, manejo correcto de codificaciones y análisis de errores típicos (validación, try-with-resources, reescritura cuidadosa).