Lecciones

Esta lección trata de qué es un «cuello de botella» en la entrada/salida y cómo detectarlo y eliminarlo. Veremos por qué las operaciones de disco y red son significativamente más lentas que la RAM, qué antipatrones son frecuentes (lectura byte a byte con read(), registros síncronos y otros), cómo ayudan los búferes ( BufferedInputStream, BufferedReader), los perfiladores ( VisualVM, JProfiler) y las mediciones de tiempo con System. currentTimeMillis (). Realizaremos un experimento práctico leyendo el archivo "bigfile.txt", compararemos la velocidad con y sin búfer, veremos la influencia de SSD/HDD y de la red y enumeraremos errores típicos.

Introducción práctica a la E/S no bloqueante de Java NIO: vemos en qué se diferencian los canales Channel y los búferes ByteBuffer de los flujos InputStream/ OutputStream, cómo leer y escribir con FileChannel, posicionarse mediante position()/ truncate(), trabajar con los parámetros del búfer ( capacity, limit, position, mark) y elegir entre allocate() y allocateDirect(). Se muestran operaciones zero-copy transferTo()/ transferFrom() y errores típicos como olvidarse de flip() y usar un modo de búfer incorrecto.

Cómo procesar de forma eficiente archivos de decenas de gigabytes sin OutOfMemoryError: los dividimos en fragmentos (chunks), leemos por posiciones mediante RandomAccessFile y FileChannel, paralelizamos las tareas con ExecutorService/ ForkJoinPool, y para una copia sencilla usamos zero-copy a través de transferTo/ transferFrom. Analizamos la elección del tamaño del fragmento, los límites de línea, la sincronización de resultados y los errores típicos.

Cómo procesar de forma segura y rápida archivos enormes en Java: leer por partes (chunking) mediante flujos y búferes, ajustar el tamaño del búfer para el rendimiento, usar el mapeo del archivo en memoria mediante MappedByteBuffer y FileChannel para acceso aleatorio ultrarrápido. Veremos pros y contras del memory mapping, recomendaciones sobre recursos y paralelismo, así como errores típicos (por ejemplo, OutOfMemoryError, descriptores olvidados, superposición de chunks en búsquedas).

Lección práctica sobre trabajo con archivos y compresión en Java: conocemos el paquete java.util.zip, los flujos ZipInputStream/ ZipOutputStream y la clase de acceso aleatorio ZipFile; gestionamos los niveles de compresión mediante Deflater ( 0… 9, DEFAULT_COMPRESSION); trabajamos con GZIPInputStream/ GZIPOutputStream para archivos individuales; y comprimimos/descomprimimos directorios con Files.walk y filtrado por PathMatcher ( "glob:**/*.txt"). Hablaremos de seguridad: protección frente a Zip Slip mediante normalización de la ruta y control de volumen frente a zip bomb, y además construiremos un mini CLI «zip/unzip» con máscaras.

Por qué y cómo «empaquetar» objetos en Java: los convertimos en un flujo de bytes y de vuelta con ObjectOutputStream/ ObjectInputStream, guardamos el estado entre ejecuciones, los enviamos por la red y almacenamos en caché los resultados. Analizamos el papel de la interfaz Serializable, los matices de la palabra clave transient y cadenas como "save.dat", hablamos de los riesgos de seguridad y la compatibilidad entre versiones. Práctica: mini guardado de la partida, envío de mensajes cliente↔servidor y cacheo de cálculos.

Analizamos los fundamentos de la serialización en Java: la interfaz marcador java.io.Serializable, cómo marcar una clase con implements Serializable, requisitos para los campos ( static, transient), ejemplos paso a paso de escritura y lectura de objetos con ObjectOutputStream/ ObjectInputStream, qué ocurre «bajo el capó» al invocar writeObject/ readObject, así como errores típicos (campos no serializables, clases internas, comportamiento de los campos static y versión de la clase mediante serialVersionUID).

En la lección compararemos la serialización binaria de Java mediante las clases ObjectOutputStream y ObjectInputStream con formatos de texto ( JSON, XML): principio de funcionamiento, velocidad y compacidad, compatibilidad de versiones y seguridad. Analizaremos ventajas y limitaciones, mostraremos la práctica con Jackson (incluida la dependencia de Maven) y daremos consejos sobre cuándo elegir cada opción, así como errores típicos.

En la lección veremos cómo serializar y deserializar objetos en Java con los flujos en pareja ObjectOutputStream y ObjectInputStream: qué es la interfaz marcadora java.io.Serializable, cómo funcionan los métodos writeObject() y readObject(), por qué los campos static y transient no se incluyen en el flujo, qué excepciones aparecen ( NotSerializableException, InvalidClassException) y en qué influye serialVersionUID. En la práctica serializaremos un objeto y una lista de objetos en un archivo y analizaremos errores típicos.

Guía práctica sobre la serialización de colecciones en Java: cómo guardar y restaurar List, Map, Set mediante ObjectOutputStream/ ObjectInputStream; por qué la mayoría de las colecciones ya implementan Serializable; requisitos para los elementos; comportamiento del orden en HashSet/ HashMap; trabajo con colecciones anidadas y vacías; trampas habituales ( InvalidClassException, serialVersionUID, transient/ static). Cerramos con un ejemplo completo de «biblioteca virtual».

Cómo interceptar la serialización estándar y tomar el control del proceso: usamos los métodos privados writeObject/ readObject con firmas estrictas ( private void writeObject( ObjectOutputStream out) throws IOException), llamamos a defaultWriteObject()/ defaultReadObject(), excluimos campos con transient, añadimos sumas de comprobación y registros, sin olvidar serialVersionUID y la compatibilidad de versiones. Analizaremos errores típicos, el trabajo con ObjectOutputStream/ ObjectInputStream y ejemplos prácticos.

Guía práctica sobre la serialización en Java: cuándo y cómo usar transient para excluir campos del flujo, qué ocurre durante la deserialización (valores por defecto), cómo restaurar el estado en el método readObject; qué es serialVersionUID, cómo declararlo ( private static final long serialVersionUID = 1L), cuándo cambiarlo y por qué es mejor definirlo explícitamente. Se muestran ejemplos funcionales, escenarios arriesgados y errores típicos.