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.

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.

Una función lambda es una expresión anónima que representa una implementación concisa de una interfaz funcional.

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 clave return.

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.

Cuando una lambda se limita a invocar un método existente de forma compatible, podemos utilizar una referencia a método con el operador ::. 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.

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"
    }
}

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.

Un Stream representa una secuencia de elementos que permite la ejecución de operaciones de procesamiento de datos de forma declarativa, secuencial o paralela.

  • No almacena datos: Un Stream no 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 Stream no extiende de Iterable, por lo que no se puede recorrer con un bucle for-each tradicional (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 Stream solo puede recorrerse una vez. Tras ejecutar una operación terminal, queda consumido y no se puede reutilizar; para otra consulta se crea un nuevo Stream.

Colección(List, Set...)Arraycolección.stream()Arrays.stream(array)filter(...)intermedia - perezosamap(...)intermedia - perezosasorted()intermedia - perezosacollect(...)terminalforEach(...)terminalResultado(p. ej. colección)Acción(p. ej. imprimir)las intermedias NO ejecutannada hasta que llega laterminal (evaluación perezosa)un Stream se consume UNA vez:elige una terminal para cada StreamforEach realiza una acción y devuelve void

//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);
        }
    }
}

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 en equals().

  • 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 del Stream.

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 del Stream en 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, usa Collectors.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 tipo long.

  • max(Comparator) / min(Comparator): Devuelve un Optional con el elemento máximo o mínimo según el comparador proporcionado.

  • findFirst() / findAny(): Devuelve un Optional con 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.

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.

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 Optional vacío en lugar de un valor especial o una referencia null.
  • Documentar el contrato: la firma del método indica que el resultado puede estar ausente.
  • Ofrecer alternativas: métodos como ifPresent, orElse y orElseThrow permiten 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.

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();
  • 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 del Supplier proporcionado.

  • orElseThrow(Supplier<? extends X> exceptionSupplier): Devuelve el valor encapsulado si está presente; de lo contrario, lanza una excepción proporcionada por el Supplier.

  • get(): Devuelve el valor encapsulado si está presente; de lo contrario, lanza una excepción NoSuchElementException.

  • 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.

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.

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.

  • clase/daw/prog/funcional.txt
  • Última modificación: 2026/11/11 09:28
  • por cesguiro