Lecciones

Práctica de las expresiones lambda en colecciones y Stream API: cómo sustituir clases anónimas por lambdas compactas, usar los métodos de las colecciones ( forEach, removeIf, sort, replaceAll) y construir canalizaciones (pipelines) de procesamiento de datos ( stream → filter → map → sorted → collect). Las compararemos con las clases anónimas, hablaremos de las variables « final» efectivamente finales, presentaremos una tabla de las operaciones principales y analizaremos errores típicos.

En la lección analizamos por qué Java incorporó las expresiones lambda: concisión y legibilidad, paso de comportamiento como parámetro, integración con colecciones y la API de Stream ( filter, map, forEach), captura de variables «efectivamente» final y una forma cómoda de escribir callbacks mediante el operador ->. Además, veremos los escollos: depuración de cadenas largas, ambigüedad en sobrecargas ( Runnable vs Callable), limitaciones de las clausuras, serialización y lambdas anidadas. Al final — recomendaciones prácticas sobre cuándo usar lambdas y un análisis de errores típicos.

En la lección explicamos qué es un closure y cómo funciona en Java: cómo las lambdas y las clases anónimas «capturan» variables externas, por qué las variables locales deben ser final o efectivamente final, en qué se diferencia la captura de variables locales del acceso a los campos de una clase y cómo se comporta this en las lambdas y en las clases anónimas. Mostraremos fábricas de funciones con IntSupplier, analizaremos la implementación interna de la captura y los errores típicos (por ejemplo, el mensaje del compilador Variable used in lambda expression should be final or effectively final).

En la lección analizamos qué es una clase anónima en Java, en qué se diferencia de una expresión lambda: sintaxis, capacidades (campos, métodos adicionales, sobrescritura de toString/ equals), ámbito y comportamiento de this, captura de variables (solo final/«efectivamente final»). Se muestran ejemplos prácticos con Runnable, Comparator, Predicate, así como recomendaciones — cuándo elegir una lambda y cuándo una clase anónima.

Analizamos las interfaces funcionales clave del paquete java.util.function: Predicate, Consumer, Supplier, Function — qué reciben/devuelven y dónde se usan en el Stream API ( filter, map, forEach, generate). Recordamos la regla «un único método abstracto» y la anotación @FunctionalInterface, escribimos lambdas, las comparamos con clases anónimas, lo practicamos con la clase User y revisamos errores típicos al elegir entre Predicate/ Function, etc.

Esta lección trata de cómo construir canalizaciones de transformaciones a partir de funciones pequeñas mediante Function y sus métodos compose y andThen. Veremos el orden de aplicación, la compatibilidad de tipos, ejemplos con Predicate ( and, or, negate), Consumer ( andThen), construiremos pipelines prácticos y comentaremos errores típicos: orden confundido ( f.compose(g) vs f.andThen(g)), tipos no concordantes y código espagueti por encadenar en exceso. Aprenderás a usar apply, test, accept y a construir transformaciones legibles y reutilizables.

Introducción práctica al paso de comportamiento en Java: cómo usar expresiones lambda ( ->) y referencias a métodos ( ::) junto con Stream API y colecciones. Revisaremos las interfaces funcionales estándar de java.util.function — Comparator, Predicate, Function, Consumer, Supplier — aprenderemos a escribir métodos genéricos, a aceptar comportamiento como parámetros y a evitar errores típicos. Practicaremos con ejemplos de Stream, Optional y utilidades propias para procesar listas.

Pasamos de bucles imperativos a canalizaciones declarativas de procesamiento de datos con Stream API: veremos operaciones intermedias y terminales, evaluación perezosa, recolección de resultados mediante toList()/ collect, las operaciones clave map, filter, sorted, flatMap, reduce, así como comprobaciones anyMatch/ allMatch/ noneMatch. Compararemos el estilo imperativo y el funcional, revisaremos ejemplos prácticos y errores típicos, incluido un forEach fuera de lugar al recolectar colecciones y un parallelStream() prematuro.

10 errores más comunes al trabajar con lambdas y Stream API en Java: captura de variables ( final/ effectively final), comportamiento de this en lambdas, efectos secundarios y paralelismo ( parallelStream()), inferencia de tipos y generics, trabajo con null y Optional, composición de funciones ( compose/ andThen), así como excepciones comprobadas (checked) (por ejemplo, IOException). Mostramos prácticas seguras: filtrado con Objects::nonNull, operaciones terminales ( sum(), collect(...)), colecciones seguras para hilos y descomposición de cadenas largas.

Cómo funciona el modelo de eventos en Java: la fuente genera un evento y los escuchadores suscritos reciben la notificación y reaccionan. Analizaremos las interfaces clave de escuchadores de Swing — ActionListener, MouseListener, KeyListener, ChangeListener, DocumentListener — y mostraremos cómo registrar manejadores mediante addActionListener e implementar el método actionPerformed. Practicaremos conectar escuchadores a JButton/ JFrame, compararemos clases anónimas y expresiones lambda, y comentaremos errores típicos y consejos prácticos.

Breve introducción práctica al modelo de eventos AWT/ Swing: creamos un botón JButton, registramos un oyente con addActionListener y manejamos en actionPerformed. Analizamos clases anónimas y expresiones lambda, oyentes populares ( MouseListener/ MouseAdapter, KeyAdapter, DocumentListener), escribimos una miniaplicación basada en JFrame, JButton, JLabel, vemos la secuencia de llamadas y los errores típicos (trabajo pesado en el manejador, carácter final de las variables en lambdas, olvido de addActionListener, eliminación de oyentes, uso de SwingWorker).

En la lección vemos cómo diseñar eventos personalizados en Java: creamos una clase de evento basada en java.util.EventObject, describimos la interfaz del escuchador mediante java.util.EventListener, añadimos el mecanismo de suscripción/cancelación de suscripción ( add...Listener/ remove...Listener) y de notificación ( fire...). Veremos la práctica con ejemplos de DataLoader y de un contador, comentaremos manejadores con clases anónimas y expresiones lambda, y también revisaremos errores típicos (excepciones en los escuchadores, fugas de memoria, ConcurrentModificationException).