Interfaz funcional Predicate

Definición y propósito de Predicate

La interfaz Predicate<T> es una de las interfaces funcionales más utilizadas en Java, introducida como parte del paquete java.util.function desde Java 8. Esta interfaz representa una función de predicado (o condición) que acepta un argumento de tipo T y produce un resultado booleano.

Un Predicate esencialmente responde a la pregunta "¿este elemento cumple cierta condición?", lo que lo convierte en una herramienta fundamental para operaciones de filtrado en colecciones de datos. Su firma funcional es simple pero poderosa:

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
    // Métodos default y static adicionales
}

El propósito principal de Predicate es encapsular lógica de evaluación en un objeto que puede pasarse como argumento, almacenarse en variables o devolverse como resultado de otros métodos. Esto facilita la creación de código más modular, reutilizable y expresivo.

Casos de uso comunes

Los predicados son especialmente útiles en situaciones donde necesitamos:

• Filtrar colecciones de elementos según ciertos criterios
• Validar que un objeto cumpla determinadas condiciones
• Definir reglas de negocio como expresiones evaluables
• Componer condiciones complejas a partir de condiciones simples

Creación de predicados

Existen varias formas de crear un Predicate en Java:

• Mediante expresiones lambda:

Predicate<Integer> esPar = numero -> numero % 2 == 0;
Predicate<String> empiezaConA = texto -> texto.startsWith("A");

• Mediante referencias a métodos:

Predicate<String> esVacio = String::isEmpty;

• Mediante implementación de clase anónima (enfoque tradicional):

Predicate<Double> esPositivo = new Predicate<Double>() {
    @Override
    public boolean test(Double valor) {
        return valor > 0;
    }
};

Uso básico de Predicate

El uso más simple de un predicado es invocar su método test() con un valor para evaluar si cumple la condición:

Predicate<Integer> mayorQueVeinte = n -> n > 20;

boolean resultado1 = mayorQueVeinte.test(25);  // true
boolean resultado2 = mayorQueVeinte.test(15);  // false

System.out.println("¿25 es mayor que 20? " + resultado1);
System.out.println("¿15 es mayor que 20? " + resultado2);

Predicados con colecciones

Uno de los usos más comunes de Predicate es en combinación con el método removeIf() de las colecciones, que elimina todos los elementos que cumplen con el predicado:

List<String> nombres = new ArrayList<>(Arrays.asList(
    "Ana", "Juan", "Pedro", "María", "José"
));

// Eliminar nombres que tengan menos de 5 caracteres
Predicate<String> nombreCorto = nombre -> nombre.length() < 5;
nombres.removeIf(nombreCorto);

System.out.println(nombres);  // [María]

También podemos usar predicados con el método filter() de Stream para seleccionar elementos:

List<Integer> numeros = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// Filtrar solo números impares
Predicate<Integer> esImpar = n -> n % 2 != 0;
List<Integer> impares = numeros.stream()
                               .filter(esImpar)
                               .collect(Collectors.toList());

System.out.println(impares);  // [1, 3, 5, 7, 9]

Ventajas de usar Predicate

El uso de la interfaz Predicate ofrece varias ventajas significativas:

• Código más declarativo: expresamos qué queremos lograr en lugar de cómo lograrlo
• Mayor reutilización: podemos definir predicados una vez y usarlos en múltiples contextos
• Mejor testabilidad: podemos probar la lógica de evaluación de forma aislada
• Composición de lógica: podemos combinar predicados simples para crear condiciones complejas
• Integración con API de Streams: funcionan perfectamente con las operaciones de filtrado en streams

La interfaz Predicate es una herramienta esencial en el paradigma de programación funcional en Java, permitiendo expresar condiciones de forma concisa y componible, lo que resulta en código más limpio y mantenible.

Implementación del método test()

El método test() es el núcleo funcional de la interfaz Predicate<T> y el único método abstracto que debemos implementar cuando creamos un predicado. Este método evalúa si un objeto de tipo T cumple con una condición específica, devolviendo true o false según corresponda.

La firma del método es simple pero efectiva:

boolean test(T t);

Donde T es el tipo de dato sobre el que operará el predicado. La implementación de este método debe contener la lógica de evaluación que determinará si el objeto pasado como argumento satisface o no la condición que queremos verificar.

Implementaciones básicas

Veamos algunas implementaciones prácticas del método test():

• Verificar si un número es primo:

Predicate<Integer> esPrimo = numero -> {
    if (numero <= 1) return false;
    if (numero <= 3) return true;
    if (numero % 2 == 0 || numero % 3 == 0) return false;
    
    for (int i = 5; i * i <= numero; i += 6) {
        if (numero % i == 0 || numero % (i + 2) == 0)
            return false;
    }
    return true;
};

System.out.println("¿17 es primo? " + esPrimo.test(17));  // true
System.out.println("¿20 es primo? " + esPrimo.test(20));  // false

• Validar formato de email:

Predicate<String> emailValido = email -> {
    String regex = "^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$";
    return email != null && email.matches(regex);
};

System.out.println(emailValido.test("usuario@dominio.com"));  // true
System.out.println(emailValido.test("texto-invalido"));       // false

• Verificar si una fecha es fin de semana:

Predicate<LocalDate> esFinDeSemana = fecha -> {
    DayOfWeek dia = fecha.getDayOfWeek();
    return dia == DayOfWeek.SATURDAY || dia == DayOfWeek.SUNDAY;
};

LocalDate sabado = LocalDate.of(2023, 7, 15);
System.out.println("¿Es fin de semana? " + esFinDeSemana.test(sabado));  // true

Implementación con objetos complejos

El método test() también puede trabajar con objetos personalizados, evaluando sus propiedades o estado:

class Producto {
    private String nombre;
    private double precio;
    private boolean disponible;
    
    // Constructor y getters
    public Producto(String nombre, double precio, boolean disponible) {
        this.nombre = nombre;
        this.precio = precio;
        this.disponible = disponible;
    }
    
    public String getNombre() { return nombre; }
    public double getPrecio() { return precio; }
    public boolean isDisponible() { return disponible; }
}

// Predicados para filtrar productos
Predicate<Producto> estaDisponible = producto -> producto.isDisponible();
Predicate<Producto> esPrecioAlto = producto -> producto.getPrecio() > 100;

// Uso con un producto
Producto laptop = new Producto("Laptop", 899.99, true);
System.out.println("¿Laptop disponible? " + estaDisponible.test(laptop));  // true
System.out.println("¿Precio alto? " + esPrecioAlto.test(laptop));          // true

Implementación con captura de variables

Una característica poderosa de las expresiones lambda es la capacidad de capturar variables del contexto donde se definen. Esto permite crear predicados parametrizados:

public static Predicate<Integer> mayorQue(int umbral) {
    return numero -> numero > umbral;
}

public static Predicate<String> contienePalabra(String palabra) {
    return texto -> texto.contains(palabra);
}

// Uso de predicados parametrizados
Predicate<Integer> mayorQue50 = mayorQue(50);
Predicate<String> contieneJava = contienePalabra("Java");

System.out.println(mayorQue50.test(75));                  // true
System.out.println(contieneJava.test("Programación en Java"));  // true

Consideraciones de implementación

Al implementar el método test(), es importante tener en cuenta:

• Inmutabilidad: El predicado no debe modificar el objeto que está evaluando.
• Consistencia: Para el mismo input, el predicado debe devolver siempre el mismo resultado (a menos que dependa explícitamente de estado externo).
• Eficiencia: La implementación debe ser lo más eficiente posible, especialmente si se usará con grandes colecciones.
• Null-safety: Considerar cómo manejar valores nulos para evitar NullPointerException.

// Predicado seguro contra nulos
Predicate<String> empiezaConA = texto -> texto != null && texto.startsWith("A");

System.out.println(empiezaConA.test(null));        // false (sin excepción)
System.out.println(empiezaConA.test("Algoritmo"));  // true

Uso en contextos prácticos

El método test() se utiliza frecuentemente en situaciones como:

• Validación de formularios:

Map<String, Predicate<String>> validadores = new HashMap<>();
validadores.put("nombre", s -> s != null && s.length() >= 2);
validadores.put("edad", s -> {
    try {
        int edad = Integer.parseInt(s);
        return edad >= 18 && edad <= 100;
    } catch (NumberFormatException e) {
        return false;
    }
});

// Validar un campo
String edadInput = "25";
boolean edadValida = validadores.get("edad").test(edadInput);
System.out.println("Edad válida: " + edadValida);  // true

• Filtrado de datos en aplicaciones:

List<Empleado> empleados = obtenerEmpleados();  // Método que devuelve lista de empleados

// Filtrar empleados según diferentes criterios
Predicate<Empleado> departamentoIT = e -> "IT".equals(e.getDepartamento());
Predicate<Empleado> salarioAlto = e -> e.getSalario() > 50000;

// Aplicar filtro
List<Empleado> itConSalarioAlto = empleados.stream()
    .filter(empleado -> departamentoIT.test(empleado) && salarioAlto.test(empleado))
    .collect(Collectors.toList());

La implementación del método test() es el punto donde definimos la lógica de evaluación específica de nuestro predicado, permitiéndonos crear condiciones personalizadas que pueden utilizarse en diversos contextos de programación funcional en Java.

Operaciones lógicas con Predicates: and, or, negate

La interfaz Predicate<T> no solo nos permite evaluar condiciones individuales, sino que también ofrece métodos default que facilitan la composición de predicados para crear condiciones más complejas. Estos métodos permiten combinar predicados existentes mediante operaciones lógicas básicas: conjunción (AND), disyunción (OR) y negación (NOT).

Método and()

El método and() permite combinar dos predicados mediante la operación lógica AND, creando un nuevo predicado que solo devuelve true cuando ambos predicados originales devuelven true:

default Predicate<T> and(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) && other.test(t);
}

Veamos un ejemplo práctico donde filtramos números que sean tanto pares como mayores que 10:

Predicate<Integer> esPar = num -> num % 2 == 0;
Predicate<Integer> mayorQue10 = num -> num > 10;

// Combinamos ambos predicados con and()
Predicate<Integer> esParYMayorQue10 = esPar.and(mayorQue10);

List<Integer> numeros = Arrays.asList(5, 8, 12, 15, 20, 25);
List<Integer> resultado = numeros.stream()
                                .filter(esParYMayorQue10)
                                .collect(Collectors.toList());

System.out.println(resultado); // [12, 20]

Este enfoque es especialmente útil cuando trabajamos con validaciones múltiples en objetos complejos:

class Producto {
    private String nombre;
    private double precio;
    private int stock;
    
    // Constructor y getters
    public Producto(String nombre, double precio, int stock) {
        this.nombre = nombre;
        this.precio = precio;
        this.stock = stock;
    }
    
    public String getNombre() { return nombre; }
    public double getPrecio() { return precio; }
    public int getStock() { return stock; }
}

// Definimos predicados individuales
Predicate<Producto> precioRazonable = p -> p.getPrecio() < 100;
Predicate<Producto> hayStock = p -> p.getStock() > 0;

// Combinamos con and() para productos disponibles para venta
Predicate<Producto> disponibleParaVenta = precioRazonable.and(hayStock);

List<Producto> inventario = Arrays.asList(
    new Producto("Teclado", 45.99, 10),
    new Producto("Monitor", 199.99, 5),
    new Producto("Mouse", 25.50, 0),
    new Producto("Auriculares", 89.99, 3)
);

List<Producto> productosDisponibles = inventario.stream()
                                              .filter(disponibleParaVenta)
                                              .collect(Collectors.toList());

// Mostramos los nombres de productos disponibles
productosDisponibles.forEach(p -> System.out.println(p.getNombre())); // Teclado, Auriculares

Método or()

El método or() combina dos predicados mediante la operación lógica OR, creando un nuevo predicado que devuelve true cuando al menos uno de los predicados originales devuelve true:

default Predicate<T> or(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) || other.test(t);
}

Veamos un ejemplo donde filtramos cadenas que sean muy cortas o muy largas:

Predicate<String> esMuyCorta = s -> s.length() < 3;
Predicate<String> esMuyLarga = s -> s.length() > 10;

// Combinamos con or()
Predicate<String> longitudExtrema = esMuyCorta.or(esMuyLarga);

List<String> palabras = Arrays.asList("a", "hola", "programación", "Java", "if");
List<String> resultado = palabras.stream()
                               .filter(longitudExtrema)
                               .collect(Collectors.toList());

System.out.println(resultado); // [a, programación, if]

El método or() es útil para crear condiciones alternativas en reglas de negocio:

// Predicados para identificar clientes prioritarios
Predicate<Cliente> esClienteAntiguo = c -> c.getAntiguedad() > 5;
Predicate<Cliente> esClientePremium = c -> c.getTipo().equals("PREMIUM");
Predicate<Cliente> tieneComprasMensuales = c -> c.getComprasMensuales() > 3;

// Un cliente es prioritario si cumple cualquiera de estas condiciones
Predicate<Cliente> esClientePrioritario = esClienteAntiguo
                                        .or(esClientePremium)
                                        .or(tieneComprasMensuales);

// Uso del predicado compuesto
clientes.stream()
       .filter(esClientePrioritario)
       .forEach(cliente -> enviarOfertaEspecial(cliente));

Método negate()

El método negate() crea un nuevo predicado que representa la negación lógica del predicado original, invirtiendo su resultado:

default Predicate<T> negate() {
    return (t) -> !test(t);
}

Este método es especialmente útil cuando necesitamos la condición opuesta a un predicado existente:

Predicate<Integer> esPar = num -> num % 2 == 0;
Predicate<Integer> esImpar = esPar.negate();

List<Integer> numeros = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> impares = numeros.stream()
                             .filter(esImpar)
                             .collect(Collectors.toList());

System.out.println(impares); // [1, 3, 5]

La negación también es útil para simplificar expresiones complejas:

// En lugar de escribir una condición compleja
Predicate<String> noEsEmailValido = email -> {
    String regex = "^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$";
    return !(email != null && email.matches(regex));
};

// Podemos negar un predicado existente
Predicate<String> esEmailValido = email -> {
    String regex = "^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$";
    return email != null && email.matches(regex);
};
Predicate<String> noEsEmailValido = esEmailValido.negate();

Combinando múltiples operaciones lógicas

La verdadera potencia de estos métodos se aprecia cuando encadenamos múltiples operaciones para crear predicados complejos:

// Predicados base
Predicate<Integer> esDivisiblePor2 = n -> n % 2 == 0;
Predicate<Integer> esDivisiblePor3 = n -> n % 3 == 0;
Predicate<Integer> mayorQue10 = n -> n > 10;
Predicate<Integer> menorQue50 = n -> n < 50;

// Predicado complejo: números entre 10 y 50 que son divisibles por 2 o por 3, pero no por ambos
Predicate<Integer> predicadoComplejo = mayorQue10.and(menorQue50)
                                     .and(esDivisiblePor2.or(esDivisiblePor3))
                                     .and(esDivisiblePor2.and(esDivisiblePor3).negate());

List<Integer> numeros = IntStream.rangeClosed(1, 60).boxed().collect(Collectors.toList());
List<Integer> resultado = numeros.stream()
                               .filter(predicadoComplejo)
                               .collect(Collectors.toList());

System.out.println(resultado); // [14, 16, 20, 22, 26, 28, 32, 34, 38, 40, 44, 46]

Método estático isEqual()

Además de los métodos de instancia, Predicate ofrece un método estático útil llamado isEqual() que crea un predicado que evalúa si un objeto es igual a una referencia dada:

static <T> Predicate<T> isEqual(Object targetRef) {
    return (null == targetRef)
            ? Objects::isNull
            : object -> targetRef.equals(object);
}

Este método es útil para crear predicados de igualdad de forma concisa:

// Buscar un elemento específico
String buscar = "Java";
Predicate<String> esJava = Predicate.isEqual(buscar);

List<String> lenguajes = Arrays.asList("Python", "Java", "JavaScript", "C#");
boolean encontrado = lenguajes.stream().anyMatch(esJava);

System.out.println("¿Se encontró Java? " + encontrado); // true

Aplicación práctica: sistema de filtrado flexible

Un caso de uso común para las operaciones lógicas con predicados es la implementación de sistemas de filtrado dinámicos:

public class FiltradorProductos {
    // Biblioteca de predicados básicos
    public static Predicate<Producto> precioMenorQue(double precio) {
        return p -> p.getPrecio() < precio;
    }
    
    public static Predicate<Producto> precioMayorQue(double precio) {
        return p -> p.getPrecio() > precio;
    }
    
    public static Predicate<Producto> enCategoria(String categoria) {
        return p -> p.getCategoria().equalsIgnoreCase(categoria);
    }
    
    public static Predicate<Producto> conStock() {
        return p -> p.getStock() > 0;
    }
    
    // Método que aplica filtros combinados
    public static List<Producto> filtrar(List<Producto> productos, Predicate<Producto> filtro) {
        return productos.stream()
                      .filter(filtro)
                      .collect(Collectors.toList());
    }
}

// Uso del sistema de filtrado
List<Producto> productos = obtenerProductos();

// Construimos filtros complejos combinando predicados
Predicate<Producto> filtroElectronicaBarata = FiltradorProductos.enCategoria("electronica")
                                           .and(FiltradorProductos.precioMenorQue(100))
                                           .and(FiltradorProductos.conStock());

// Aplicamos el filtro
List<Producto> electronicsBaratos = FiltradorProductos.filtrar(productos, filtroElectronicaBarata);

Las operaciones lógicas con predicados nos permiten construir condiciones complejas de forma declarativa y modular, facilitando la creación de sistemas de filtrado flexibles y mantenibles. Esta capacidad de composición es una de las características más potentes de la programación funcional en Java.