06 - Programación Funcional
Un informe puede necesitar sumar valores, seleccionar elementos de una colección o buscar el mayor. Con las colecciones y los bucles que ya conocemos podemos hacerlo, pero es fácil repetir recorridos y mezclar los cálculos con su presentación.
La programación funcional ofrece herramientas para expresar qué queremos hacer: filtrar, transformar, sumar o buscar. Se centra en la composición y aplicación de funciones y favorece la ausencia de efectos secundarios. En Java convive con la programación orientada a objetos y utiliza las interfaces, colecciones y excepciones ya estudiadas.
1. Principios Fundamentales
Los principios que sustentan la programación funcional proporcionan una guía para escribir código modular, expresivo y menos propenso a errores:
- Funciones como Ciudadanos de Primera Clase: Las funciones se tratan como cualquier otro tipo de dato. Pueden asignarse a variables, pasarse como argumentos a otros métodos y devolverse como resultado.
- Inmutabilidad: Una vez creado un objeto o estructura de datos, su estado no debe modificarse. En lugar de alterar el objeto existente, se generan nuevas instancias con los valores actualizados. Esto previene efectos colaterales y facilita la concurrencia.
- Pureza de las Funciones: Una función pura produce siempre el mismo resultado para las mismas entradas y no genera efectos secundarios observables (como modificar variables globales o alterar archivos).
- Composición y Funciones de Orden Superior: Las funciones de orden superior son aquellas que reciben otras funciones por parámetro o las devuelven como resultado, permitiendo construir abstracciones complejas combinando bloques simples.
Java no obliga a que los objetos sean inmutables ni a que las funciones sean puras. Por ejemplo, escribir en consola es un efecto secundario que puede ser necesario; conviene separarlo de los cálculos cuando sea posible.
2. Funciones Lambda e Interfaces Funcionales
Una función lambda es una expresión anónima que representa una implementación concisa de una interfaz funcional.
2.1 Sintaxis de las Expresiones Lambda
La sintaxis básica de una función lambda en Java consta de tres partes:
- Parámetros: Entre paréntesis y separados por comas. Si el tipo puede ser inferido por el compilador, se puede omitir el tipo implícito. Si solo hay un parámetro, se pueden omitir los paréntesis.
- Operador Flecha (
→): Separa la declaración de parámetros del cuerpo de la función.
- Cuerpo: Si contiene una única expresión, no requiere llaves
{}ni la palabra clavereturn.
Los siguientes ejemplos incluyen tanto clases completas como fragmentos que deben colocarse dentro de un método. Para estos últimos, importa los tipos necesarios de java.util, java.util.function y java.util.stream.
Consumer<String> printer = phrase -> IO.println(phrase); printer.accept("Hola"); // Ejecuta la lambda Supplier<Integer> randomValue = () -> (int) (Math.random() * 100); Function<Integer, String> printNumber = (number) -> { if (number % 2 == 0) { return number + " es par"; } else { return number + " es impar"; } };
La lambda no se ejecuta al asignarla, sino al invocar el método de la interfaz, como accept, get o apply.
::. Por ejemplo, phrase → IO.println(phrase) puede escribirse como IO::println.
Esta sintaxis no ejecuta el método inmediatamente, sino que le indica al compilador que reutilice el método existente para implementar la interfaz funcional correspondiente, logrando un código más limpio y legible.
2.2 Interfaces Funcionales
En Java, una interfaz funcional es aquella que contiene un único método abstracto; también puede incluir métodos default o static. Una expresión lambda se adapta a una interfaz funcional compatible.
Para garantizar que una interfaz mantenga este contrato, se utiliza la anotación @FunctionalInterface:
@FunctionalInterface public interface IntegerOperation { int operation(int a, int b); }
public class IntegerOperationExample { static void main() { IntegerOperation integerOperation = Integer::sum; int result = integerOperation.operation(5, 10); IO.println("Resultado de la suma: " + result); // Imprime "Resultado de la suma: 15" integerOperation = Integer::compare; result = integerOperation.operation(5, 10); IO.println("Resultado de la comparación: " + result); // Imprime "Resultado de la comparación: -1" integerOperation = Integer::max; result = integerOperation.operation(5, 10); IO.println("Resultado de la maximización: " + result); // Imprime "Resultado de la maximización: 10" } }
2.3 Interfaces Funcionales Estándar (java.util.function)
Java proporciona un conjunto de interfaces funcionales predefinidas en el paquete java.util.function para cubrir los casos de uso habituales:
| Interfaz | Firma del Método | Propósito | Ejemplo |
|---|---|---|---|
Consumer<T> | void accept(T t) | Recibe un valor y realiza una acción sin devolver nada (efecto secundario). | s → IO.println(s) |
Predicate<T> | boolean test(T t) | Evalúa una condición sobre el argumento y devuelve un booleano. | i → i > 0 |
Function<T, R> | R apply(T t) | Transforma un argumento de tipo T en un resultado de tipo R. | s → s.length() |
Supplier<T> | T get() | No recibe argumentos y genera/devuelve un valor de tipo T. | () → “Hello World” |
import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Predicate; import java.util.function.Supplier; public class FunctionalStandard { static void main() { Consumer<String> printer = IO::println; printer.accept("Hello, World!"); // Imprime Hello, World! Predicate<Integer> isPositive = (number) -> number > 0; IO.println("¿Es 5 positivo? " + isPositive.test(5)); // Devuelve true IO.println("¿Es -3 positivo? " + isPositive.test(-3)); // Devuelve false Function<Integer, String> printNumber = (number) -> { if (number % 2 == 0) { return number + " es par"; } else { return number + " es impar"; } }; IO.println(printNumber.apply(42)); // Devuelve "42 es par" IO.println(printNumber.apply(43)); // Devuelve "43 es impar" Supplier<String> greeting = () -> "¡Hola, Mundo!"; IO.println(greeting.get()); // Imprime "¡Hola, Mundo!" } }
Existen además variantes binarias como BiConsumer<T, U>, BiPredicate<T, U> o BiFunction<T, U, R> para operar sobre dos argumentos simultáneamente. En BiFunction, T y U son los tipos de entrada y R el del resultado.
3. La API Stream (java.util.stream)
Un Stream representa una secuencia de elementos que permite la ejecución de operaciones de procesamiento de datos de forma declarativa, secuencial o paralela.
3.1 Ciclo de Vida y Características
- No almacena datos: Un
Streamno es una colección; describe el procesamiento de los datos de una fuente. Las operaciones habituales no modifican por sí mismas esa fuente, pero las lambdas pueden introducir efectos secundarios o modificar sus elementos. Evita modificar la fuente mientras se procesa.
- No es iterable: La interfaz
Streamno extiende deIterable, por lo que no se puede recorrer con un buclefor-eachtradicional (for (T item : stream)). El procesamiento se realiza exclusivamente a través de sus propios métodos.
- Encadenamiento de Operaciones: Permite encadenar múltiples operaciones intermedias de forma continua, formando una canalización (pipeline) de procesamiento.
- Evaluación Perezosa: Las operaciones intermedias no ejecutan ningún cálculo en el momento de su definición. Solo se procesan los datos cuando se invoca obligatoriamente una operación terminal.
- Consumo Único: Un
Streamsolo puede recorrerse una vez. Tras ejecutar una operación terminal, queda consumido y no se puede reutilizar; para otra consulta se crea un nuevoStream.
3.2 Creación de Streams
//1. A partir de de colecciones List<Integer> numberList = List.of(1, 2, 3, 4, 5); Stream<Integer> numberStream = numberList.stream(); // 2. A partir de un Array String[] nameArray = {"Alice", "Bob", "Charlie"}; Stream<String> streamFromArray = Arrays.stream(nameArray); // 3. A partir de valores directos Stream<Integer> streamFromValues = Stream.of(1, 2, 3, 4, 5);
Estos son solo algunos ejemplos de cómo crear Streams en Java a partir de diferentes fuentes de datos. La versatilidad de los Streams permite procesar una amplia variedad de datos de manera funcional y eficiente.
Además, la clase Stream proporciona métodos como toList() y toArray() que facilitan la conversión de un Stream en colecciones tradicionales de Java. Estas operaciones de recopilación son útiles para interactuar con APIs que esperan tipos de colección estándar, proporcionando una forma fluida y eficiente de manipular y transformar datos en Java.
import java.util.List; import java.util.stream.Stream; public class StreamExample { static void main() { List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); Stream<Integer> evenNumbers = numbers.stream() .filter(n -> n % 2 == 0); /* Error: La clase Stream no es iterable for (Integer evenNumber : evenNumbers) { IO.println("Even number: " + evenNumber); }*/ // List<Integer> evenNumbersList = numbers.stream() .filter(n -> n % 2 == 0) .toList(); for (Integer evenNumber : evenNumbersList) { IO.println("Even number: " + evenNumber); } } }
3.3 Operaciones Intermedias y Terminales
Operaciones Intermedias
Transforman el Stream en otro Stream diferente y se pueden encadenar indefinidamente. Al ser perezosas, no procesan la información de inmediato. Algunas de las más comunes:
filter(Predicate<T>): Retiene únicamente los elementos que cumplen la condición.
map(Function<T, R>): Transforma cada elemento aplicando una función.
sorted() / sorted(Comparator<T>): Ordena los elementos según su orden natural o un comparador.
distinct(): Elimina duplicados basándose enequals().
peek(Consumer): Realiza una acción sobre cada elemento a medida que se procesa (muy útil para depurar o hacer logging) sin modificar la secuencia delStream.
peek sirve principalmente para depurar. No dependas de sus efectos secundarios: el cortocircuito o las optimizaciones pueden hacer que no se ejecute para todos los elementos. Una terminal como findFirst o anyMatch puede terminar en cuanto encuentra lo que necesita; en cambio, ordenar puede requerir examinar todos los elementos.
En esta canalización, la fuente contiene nombres; filter selecciona los que empiezan por «J», map los transforma, sorted los ordena y la terminal toList obtiene el resultado:
List<String> names = List.of("John", "Jane", "Bob", "Jack"); List<String> result = names.stream() .filter(name -> name.startsWith("J")) .map(String::toUpperCase) .sorted() .toList(); IO.println(result); // [JACK, JANE, JOHN]
Otros ejemplos de operaciones individuales:
List<String>names = List.of("John", "Jane", "Bob", "Jack", "Doe"); List<String> filteredNames = names.stream() .filter(name -> name.startsWith("J")) .peek(name -> IO.println("Nombre filtrado: " + name)) // Muestra los nombres filtrados .toList(); // Filtra los nombres que empiezan por J List<Integer> lengths = names.stream() .map(String::length) .peek(length -> IO.println("Longitud del nombre: " + length)) // Muestra la longitud de cada nombre .toList(); // Mapea los nombres a su longitud List<String> sortedNames = names.stream() .sorted() .peek(name -> IO.println("Nombre ordenado: " + name)) // Muestra los nombres ordenados .toList(); // Ordena los nombres alfabéticamente List<Integer> numbers = List.of(1, 2, 2, 3, 4, 4, 5); List<Integer> uniqueNumbers = numbers.stream() .distinct() .peek(number -> IO.println("Número único: " + number)) // Muestra los números únicos .toList(); // Obtiene los números únicos
Operaciones Terminales
Inician el procesamiento de los datos y producen un resultado final o un efecto secundario. Algunas de las más comunes:
toList()/collect(Collector): Recoge los elementos delStreamen una colección:
toList(): Devuelve una lista no modificable. Sus elementos, sin embargo, pueden ser mutables.
collect(Collectors.toSet())/collect(Collectors.toList()): Recoge los elementos en un conjunto o una lista.Collectors.toList()no garantiza el tipo ni la mutabilidad de la lista; si necesitas una lista modificable, usaCollectors.toCollection(ArrayList::new).
forEach(Consumer): Ejecuta una acción para cada elemento de la secuencia.
reduce(…): Combina todos los elementos en un único valor mediante una operación de acumulación.
count(): Devuelve el número total de elementos procesados como un valor de tipolong.
max(Comparator) / min(Comparator): Devuelve unOptionalcon el elemento máximo o mínimo según el comparador proporcionado.
findFirst() / findAny(): Devuelve unOptionalcon el primer elemento o con cualquier elemento que cumpla la condición.
anyMatch() / allMatch() / noneMatch(Predicate): Evalúan una condición y devuelven un valor booleano con el resultado.\
List<Integer> numbers = List.of(1, 19, 45, 19, 34, 99, 86); // Crea una lista con los números pares List<Integer> evenNumbers = numbers.stream() .filter(n -> n % 2 == 0) .toList(); // Imprimir cada número incrementado en 5 numbers.forEach(n -> IO.println(n + 5)); // Sumar todos los números usando reduce int sum = numbers.stream() .reduce(0, Integer::sum); // Filtrar números pares y contarlos long countEven = numbers.stream() .filter(n -> n % 2 == 0) .count(); // Obtener el número máximo o lanza una excepción si la lista está vacía int max = numbers.stream() .max(Integer::compare) .orElseThrow(() -> new RuntimeException("Lista vacía")); List<Integer> emptyList = List.of(); Optional<Integer> emptyMax = emptyList.stream().max(Integer::compare); IO.println(emptyMax); // Optional.empty // Obtiene el primer elemento que es mayor que 20 Optional<Integer> firstGreaterThan20 = numbers.stream() .filter(n -> n > 20) .findFirst(); // Obtiene cualquier elemento que es mayor que 20 Optional<Integer> anyGreaterThan20 = numbers.stream() .filter(n -> n > 20) .findAny(); // Comprueba si AL MENOS existe un elemento mayor que 20 boolean hasGreaterThan20 = numbers.stream() .anyMatch(n -> n > 20); // Comprueba si TODOS los elementos son mayor que 20 boolean allGreaterThan20 = numbers.stream() .allMatch(n -> n > 20); // Comprueba si NINGÚN elemento es mayor que 20 boolean noneGreaterThan20 = numbers.stream() .noneMatch(n -> n > 20);
Para una lista vacía, anyMatch devuelve false, mientras que allMatch y noneMatch devuelven true: no hay elementos que contradigan esas dos condiciones. findAny no garantiza devolver el primero.
3.4 Sumas y agrupaciones
Cuando queremos sumar un valor entero de cada objeto, mapToInt produce un IntStream con el método sum(). Para clasificar objetos por una clave, Collectors.groupingBy devuelve un mapa cuyos valores son listas:
import java.util.List; import java.util.Map; import java.util.stream.Collectors; public class HeroReports { record Hero(String name, String heroClass, int power) {} static void main() { List<Hero> heroes = List.of( new Hero("Ada", "Maga", 80), new Hero("Leo", "Guerrero", 60), new Hero("Eva", "Maga", 90) ); int totalPower = heroes.stream() .mapToInt(Hero::power) .sum(); IO.println(totalPower); // 230 Map<String, List<Hero>> byClass = heroes.stream() .collect(Collectors.groupingBy(Hero::heroClass)); IO.println(byClass.get("Maga")); // Ada y Eva } }
Con una lista vacía, la suma es 0 y el mapa está vacío. El orden de las claves del mapa no está garantizado: si la presentación necesita un orden concreto, hay que especificarlo o ordenar al mostrar.
4. La Clase Optional<T>
Optional<T> es un contenedor que puede albergar un valor no nulo o representar su ausencia. Como tipo de retorno, hace explícito que una búsqueda puede no encontrar un resultado y permite a quien llama decidir qué hacer.
Sus principales utilidades son:
- Expresar la ausencia: una búsqueda puede devolver un
Optionalvacío en lugar de un valor especial o una referencianull. - Documentar el contrato: la firma del método indica que el resultado puede estar ausente.
- Ofrecer alternativas: métodos como
ifPresent,orElseyorElseThrowpermiten actuar cuando hay valor o decidir qué hacer cuando falta.
Optional.empty() es un objeto que representa la ausencia, no una referencia null. El tipo no impide que alguien devuelva null en lugar de un Optional, ni evita automáticamente todos los NullPointerException. Por convenio, un método que declara Optional<T> debe devolver un Optional con valor o vacío, nunca null.
4.1 Creación de Instancias
Optional<Integer> opt = Optional.of(5); // of exige un valor no nulo; ofNullable acepta null Integer nullableValue = null; Optional<Integer> optNullable = Optional.ofNullable(nullableValue); // Instancia explícitamente vacía Optional<Integer> optEmpty = Optional.empty();
4.2 Métodos Principales
isPresent: Verifica si el Optional contiene un valor.
orElse(T other): Devuelve el valor encapsulado si está presente; de lo contrario, devuelve el valor proporcionado como argumento.
orElseGet(Supplier<? extends T> supplier): Devuelve el valor encapsulado si está presente; de lo contrario, devuelve el resultado obtenido delSupplierproporcionado.
orElseThrow(Supplier<? extends X> exceptionSupplier): Devuelve el valor encapsulado si está presente; de lo contrario, lanza una excepción proporcionada por elSupplier.
get(): Devuelve el valor encapsulado si está presente; de lo contrario, lanza una excepciónNoSuchElementException.
ifPresent(Consumer<? super T> consumer): Ejecuta la acción proporcionada si el valor está presente.
Optional<String> optionalString = Optional.of("Hola, mundo!"); Optional<String> optionalStringEmpty = Optional.empty(); if (optionalString.isPresent()) { IO.println(optionalString.get()); // Imprime "Hola, mundo!" } else { IO.println("El valor no está presente"); } optionalString.ifPresent(IO::println); // Imprime "Hola, mundo!" optionalStringEmpty.ifPresent(IO::println); // No imprime nada IO.println(optionalStringEmpty.orElse("Valor por defecto")); try { optionalStringEmpty.orElseThrow(() -> new IllegalStateException("Valor no presente")); } catch (IllegalStateException exception) { IO.println(exception.getMessage()); // Valor no presente } IO.println("El programa continúa");
get() solo es seguro cuando hemos comprobado que hay un valor. Cuando baste con ejecutar una acción, ifPresent expresa la intención directamente, sin comprobar y extraer el valor por separado. Ante el máximo de una colección vacía también podemos conservar el Optional, lanzar una excepción apropiada o dar un valor alternativo si tiene sentido para la aplicación.
4.3 Diferencia entre orElse y orElseGet
El argumento de orElse se evalúa antes de llamar al método, incluso cuando hay valor. En cambio, orElseGet solo ejecuta su proveedor si el Optional está vacío:
import java.util.Optional; public class OptionalFallback { static String defaultName() { IO.println("Calculando alternativa"); return "Sin nombre"; } static void main() { Optional<String> name = Optional.of("Ada"); Optional<String> missing = Optional.empty(); String first = name.orElse(defaultName()); // Calcula la alternativa String second = name.orElseGet(OptionalFallback::defaultName); // No la calcula String third = missing.orElseGet(OptionalFallback::defaultName); // La calcula IO.println(first); // Ada IO.println(second); // Ada IO.println(third); // Sin nombre } }
Usa orElseGet si calcular la alternativa es costoso o tiene efectos secundarios. Optional se utiliza principalmente para expresar un resultado que puede faltar; evita usarlo como parámetro por rutina si hay una interfaz más clara.
Ejercicios
Implementa métodos para cada ejercicio y prueba también listas vacías. Salvo que se indique lo contrario, considera que las listas y sus elementos no son null.
Ejercicio 1
Dada una lista de enteros List<Integer>, calcula la suma de todos sus elementos utilizando la API Stream.
Por ejemplo, [2, 5, 3] devuelve 10 y [] devuelve 0. Compara mapToInt(…).sum() con reduce.
Ejercicio 2
Dada una lista de enteros List<Integer>, devuelve una nueva lista que contenga únicamente los números pares.
Ejercicio 3
Dada una lista de cadenas de texto List<String>, devuelve una nueva lista con todas las cadenas convertidas a mayúsculas.
Ejercicio 4
Dada una lista de enteros List<Integer>, encuentra el número máximo utilizando Streams y Optional.
Para [4, 9, 2] devuelve Optional[9]; para [], un Optional vacío. Muestra un mensaje si no existe el máximo, sin usar get() sin comprobar.
Ejercicio 5
Dada una lista de enteros List<Integer> y un valor límite int limit, cuenta cuántos elementos de la lista son estrictamente mayores que dicho valor.
Ejercicio 6
Dada una lista de cadenas List<String>, concatena todos sus elementos en una única cadena separada por comas utilizando Streams.
Ejercicio 7
Dada una lista de enteros List<Integer>, devuelve una lista con el cuadrado de cada uno de sus números.
Ejercicio 8
Dada una lista de enteros List<Integer> que contiene valores repetidos, devuelve una nueva lista sin duplicados.
Ejercicio 9
Dada una lista de enteros List<Integer> y un valor de referencia int threshold, devuelve el primer número de la lista que sea mayor que dicho valor envuelto en un Optional.
Ejercicio 10
Dada una lista de cadenas List<String> y un prefijo String prefix, cuenta cuántas cadenas de la lista empiezan por dicho prefijo (sin importar mayúsculas o minúsculas). Para normalizar independientemente de la configuración regional, considera toLowerCase(Locale.ROOT).
Ejercicio 11: Canalización compuesta
Selecciona los nombres que empiezan por «a» sin distinguir mayúsculas, conviértelos a mayúsculas, elimina duplicados y ordénalos. Para [“ana”, “Luis”, “Alba”, “ANA”] el resultado es [“ALBA”, “ANA”]. Describe las operaciones intermedias y la terminal.
Ejercicio 12: Informes y agrupación
Con los héroes del ejemplo de la sección 3.4, calcula el poder total, comprueba si alguno tiene al menos 90 de poder, busca el de mayor poder como Optional<Hero> y agrúpalos por clase. Comprueba los resultados con una plantilla vacía y decide cómo mostrar las clases en orden alfabético.
Aplica estas operaciones en La Forja: los informes del gremio.