Programación Funcional en Java

La programación funcional representa un paradigma de programación que trata la computación como la evaluación de funciones matemáticas, evitando el cambio de estado y los datos mutables. Java, tradicionalmente orientado a objetos, incorporó características funcionales a partir de Java 8, permitiendo a los desarrolladores combinar ambos paradigmas de manera efectiva.

Fundamentos del paradigma funcional

En la programación funcional, las funciones son ciudadanos de primera clase, lo que significa que pueden ser asignadas a variables, pasadas como argumentos y devueltas como valores de retorno. Este enfoque contrasta con la programación imperativa, donde nos centramos en cómo hacer algo, mientras que la programación funcional se enfoca en qué queremos obtener.

Los principios fundamentales incluyen la inmutabilidad, donde los objetos no cambian después de su creación, y la ausencia de efectos secundarios, donde las funciones no modifican el estado externo. Estos conceptos reducen la complejidad del código y facilitan el razonamiento sobre el comportamiento del programa.

// Enfoque imperativo tradicional
List<String> nombres = Arrays.asList("Ana", "Carlos", "Beatriz");
List<String> resultado = new ArrayList<>();
for (String nombre : nombres) {
    if (nombre.length() > 3) {
        resultado.add(nombre.toUpperCase());
    }
}

// Enfoque funcional
List<String> resultado = nombres.stream()
    .filter(nombre -> nombre.length() > 3)
    .map(String::toUpperCase)
    .collect(Collectors.toList());

Interfaces funcionales

Las interfaces funcionales constituyen la base de la programación funcional en Java. Una interfaz funcional contiene exactamente un método abstracto y puede ser implementada mediante expresiones lambda o referencias a métodos. Java proporciona varias interfaces funcionales predefinidas en el paquete java.util.function.

La interfaz Function<T, R> representa una función que acepta un argumento de tipo T y produce un resultado de tipo R:

Function<String, Integer> longitud = texto -> texto.length();
Function<Integer, Integer> cuadrado = numero -> numero * numero;

// Uso de las funciones
int resultado1 = longitud.apply("Hola mundo"); // 10
int resultado2 = cuadrado.apply(5); // 25

La interfaz Predicate<T> define una función que evalúa una condición y devuelve un valor booleano:

Predicate<Integer> esPar = numero -> numero % 2 == 0;
Predicate<String> esVacio = String::isEmpty;

// Evaluación de predicados
boolean resultado1 = esPar.test(4); // true
boolean resultado2 = esVacio.test(""); // true

Expresiones lambda y referencias a métodos

Las expresiones lambda proporcionan una sintaxis concisa para implementar interfaces funcionales. Su estructura básica es (parámetros) -> expresión o (parámetros) -> { bloque de código }:

// Lambda simple
Comparator<String> porLongitud = (a, b) -> a.length() - b.length();

// Lambda con bloque
Consumer<String> imprimir = mensaje -> {
    System.out.println("Mensaje: " + mensaje);
    System.out.println("Longitud: " + mensaje.length());
};

Las referencias a métodos ofrecen una forma aún más concisa de referenciar métodos existentes. Existen cuatro tipos principales:

1 - Referencias a métodos estáticos:

Function<String, Integer> parser = Integer::parseInt;
// Equivale a: s -> Integer.parseInt(s)

2 - Referencias a métodos de instancia:

String texto = "Hola";
Supplier<Integer> longitud = texto::length;
// Equivale a: () -> texto.length()

3 - Referencias a métodos de instancia de un tipo particular:

Function<String, String> mayusculas = String::toUpperCase;
// Equivale a: s -> s.toUpperCase()

4 - Referencias a constructores:

Supplier<ArrayList<String>> constructor = ArrayList::new;
// Equivale a: () -> new ArrayList<>()

Composición de funciones

La composición de funciones permite combinar funciones simples para crear operaciones más complejas. Java proporciona métodos como compose() y andThen() para facilitar esta tarea:

Function<String, String> limpiar = texto -> texto.trim();
Function<String, String> mayusculas = String::toUpperCase;
Function<String, Integer> longitud = String::length;

// Composición usando andThen
Function<String, Integer> procesarTexto = limpiar
    .andThen(mayusculas)
    .andThen(longitud);

int resultado = procesarTexto.apply("  hola mundo  "); // 10

Los predicados también pueden combinarse usando operadores lógicos:

Predicate<Integer> mayorQueCero = n -> n > 0;
Predicate<Integer> menorQueDiez = n -> n < 10;

Predicate<Integer> enRango = mayorQueCero.and(menorQueDiez);
Predicate<Integer> fueraDeRango = enRango.negate();

boolean resultado1 = enRango.test(5); // true
boolean resultado2 = fueraDeRango.test(15); // true

Inmutabilidad y efectos secundarios

La inmutabilidad es un principio fundamental que implica que los objetos no pueden modificarse después de su creación. Esto elimina muchos errores relacionados con el estado compartido y facilita el razonamiento sobre el código:

// Clase inmutable
public final class Punto {
    private final int x;
    private final int y;
    
    public Punto(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    public int getX() { return x; }
    public int getY() { return y; }
    
    // Método que devuelve una nueva instancia
    public Punto mover(int deltaX, int deltaY) {
        return new Punto(x + deltaX, y + deltaY);
    }
}

Los efectos secundarios son cambios en el estado del programa que ocurren fuera del valor de retorno de una función. Las funciones puras evitan estos efectos, lo que las hace más predecibles y fáciles de probar:

// Función con efectos secundarios (evitar)
private static int contador = 0;
public static int incrementar(int valor) {
    contador++; // Efecto secundario
    return valor + 1;
}

// Función pura (preferible)
public static int incrementar(int valor) {
    return valor + 1; // Solo depende de sus parámetros
}

La programación funcional en Java ofrece herramientas valiosas para escribir código más expresivo, mantenible y menos propenso a errores, especialmente cuando se combina juiciosamente con los principios de la programación orientada a objetos.