Programación Funcional Lambda – Functional Interfaces, Streams, map, filter, reduce

Este artículo es una explicación conceptual sobre programación funcional, incluyendo preguntas de examen y etiquetas.

En Resumen

La programación funcional se centra en el cálculo mediante funciones en lugar de cambios de estado. Las expresiones Lambda son funciones literales inline que en Java se vinculan al tiempo de ejecución a través de Functional Interfaces, que poseen exactamente un método abstracto.

Descripción Técnica Compacta

Una expresión Lambda describe un comportamiento anónimo con parámetros, cuerpo y tipo de retorno opcional. El tipo se deduce del contexto destino, o Target Type, por ejemplo un Functional Interface como Predicate, Function, Consumer o Supplier. Los Functional Interfaces permiten Higher Order Functions: las funciones se pasan como valores, se retornan y se almacenan. Los principios centrales son Pure Functions (entrada inmutable genera salida determinista sin efectos secundarios), Referential Transparency e Immutability, que reducen acoplamiento y facilitan testing y paralelización.

Puntos Clave para Examen

• Conocer la sintaxis Lambda: lista de parámetros, flecha, cuerpo, Target Type derivado del Functional Interface
• Interfaces estándar: Function T,R, Predicate T, Consumer T, Supplier T, UnaryOperator T, BinaryOperator T
• Streams, map, filter, flatMap, reduce, collect, explicar brevemente y justificar complejidad típica
• Relevancia IHK: diferencias imperativo vs. funcional, evitar efectos secundarios, ventajas para testabilidad y paralelización
• Práctica: referencias a métodos, ClassName::staticMethod, instance::method, Constructor::new
• Seguridad: sin efectos secundarios ocultos en Lambdas, thread safety mediante Immutability
• Aspectos económicos: menos boilerplate, flujo de datos más claro, mejor mantenibilidad, tasa de errores potencialmente menor
• Obligación de documentación: contrato de función, dominio de entrada, efectos secundarios, concurrencia, complejidad

Componentes Clave

1. Sintaxis Lambda: parámetros, cuerpo, retorno
2. Functional Interface con exactamente un método abstracto (SAM)
3. Referencias a métodos como forma compacta de escritura
4. Higher Order Functions: funciones como parámetros o valores de retorno
5. Pure Function y efectos secundarios, testabilidad, determinismo
6. Immutability y thread safety
7. Stream Pipeline, Lazy Evaluation, operadores de cortocircuito
8. Closures y effectively final en Java
9. Patrones opcionales y de error: Optional, Try, Either
10. Parallel Streams, independencia de datos, Boxed vs. Primitive Streams

Ejemplo Práctico

// Java, filtrar y transformar datos con Lambdas y Streams
List<String> names = List.of("Mila", "Tom", "Amir", "Mara")
List<Integer> lengths = names.stream()
.filter(n -> n.startsWith("M"))
.map(String::length)
.sorted()
.toList()

// Custom Functional Interface y Lambda
@FunctionalInterface
interface IntOp { int apply(int a, int b) }
IntOp add = (a, b) -> a + b
IntOp max = Math::max
int r1 = add.apply(3, 4) // 7
int r2 = max.apply(5, 9) // 9

Explicación: la Stream Pipeline muestra map, filter, sorted, toList. Los Lambdas son puros y sin efectos secundarios.

Ventajas e Inconvenientes

Ventajas

• Menos boilerplate, estilo declarativo más claro
• Mejor testabilidad mediante Pure Functions
• Paralelización sencilla gracias a Immutability
• Alta reutilización mediante combinadores

Inconvenientes

• Curva de aprendizaje con abstracciones como Higher Order Functions
• Debugging en pipelines más difícil
• Captures descuidadas pueden retener memoria
• En Java, limitaciones por effectively final y Erasure

Preguntas Típicas de Examen (con Respuesta Breve)

1. ¿Expresión Lambda en Java y determinación de tipo? Literal de función anónimo cuyo tipo se deduce del contexto destino, un Functional Interface con un método abstracto.

2. ¿Cuatro Functional Interfaces centrales de java.util.function? Function T,R, Predicate T, Consumer T, Supplier T; además Operators que mapean T hacia T.

3. ¿Método como Lambda vs. Referencia a Método? Las referencias a métodos apuntan directamente a métodos existentes, son equivalentes a un Lambda pero más breves y legibles.

4. ¿Effectively final en Closures? Las variables locales usadas en Lambdas no pueden ser modificadas tras su asignación; la JVM puede capturarlas de forma segura.

5. ¿Referential Transparency y por qué es importante? Una expresión puede reemplazarse por su valor sin cambiar el comportamiento del programa; promueve testabilidad y razonamiento.

6. ¿Cómo funciona Reduce en una Stream Pipeline? Combina elementos iterativamente con un acumulador asociativo e identidad opcional, por ejemplo reduce(0, Integer::sum).

7. ¿Riesgos de Parallel Streams? Acumuladores no asociativos generan resultados incorrectos; Lambdas con efectos secundarios no son seguras.

8. ¿Modelar errores funcionalmente? Mediante valores como Optional para ausencia, Try o Either para éxito o fallo, en lugar de lanzar Exceptions globales.

9. ¿Bucle imperativo vs. Pipeline funcional? Imperativo: mutación y control explícitos; funcional: flujo de datos declarativo, Immutability, más fácil de testear.

10. ¿Functional Interfaces vs. tipos de función verdaderos? Java usa tipos SAM como sustituto; lenguajes como Kotlin, Scala y Haskell poseen tipos de función nativos con aridad.

Fuentes Más Importantes

1. https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html
2. https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html
3. https://de.wikipedia.org/wiki/Funktionale_Programmierung

Recomendación de Libro