Predicados Simples y Compuestos en Java

¿Qué son los predicados simples y compuestos?

En Java, un predicado es una función que toma uno o más argumentos y devuelve un valor booleano (true o false). Los predicados se utilizan para evaluar condiciones y tomar decisiones en el código.

Predicados Simples

Un predicado simple es una función que evalúa una sola condición. Por ejemplo, un predicado que verifica si un número es mayor que 10 podría ser:

public boolean esMayorQueDiez(int numero) {
    return numero > 10;
}

Predicados Compuestos

Un predicado compuesto es una función que combina múltiples predicados simples utilizando operadores lógicos como && (AND), || (OR) y ! (NOT). Por ejemplo, un predicado compuesto que verifica si un número es mayor que 10 y menor que 20 podría ser:

public boolean estaEntreDiezYVeinte(int numero) {
    return numero > 10 && numero < 20;
}

Uso de Predicados en Java

En Java, contamos con las interfaces funcionales Predicate<T> y BiPredicate<T, U> en el paquete java.util.function, que nos permiten trabajar con predicados de manera más flexible, especialmente en el contexto de expresiones lambda.

Predicate

La interfaz Predicate<T> representa un predicado que toma un argumento de tipo T y devuelve un valor booleano. Por ejemplo:

import java.util.function.Predicate;

public class PredicadoEjemplo {
    public static void main(String[] args) {
        Predicate<Integer> esMayorQueDiez = numero -> numero > 10;
        
        System.out.println(esMayorQueDiez.test(15)); // true
        System.out.println(esMayorQueDiez.test(5));  // false
    }
}

En este ejemplo, se define un predicado que verifica si un número es mayor que 10 utilizando una expresión lambda.

BiPredicate<T, U>

La interfaz BiPredicate<T, U> representa un predicado que toma dos argumentos de tipos T y U y devuelve un valor booleano. Por ejemplo:

import java.util.function.BiPredicate;

public class BiPredicadoEjemplo {
    public static void main(String[] args) {
        BiPredicate<Integer, Integer> esMayor = (a, b) -> a > b;
        
        System.out.println(esMayor.test(15, 10)); // true
        System.out.println(esMayor.test(5, 10));  // false
    }
}

En este ejemplo, se define un BiPredicate que verifica si el primer número es mayor que el segundo número utilizando una expresión lambda.

Function, Consumer y Supplier

Además de Predicate y BiPredicate, Java proporciona otras interfaces funcionales como Function<T, R>, Consumer<T> y Supplier<T>, que se utilizan para representar funciones que toman argumentos y devuelven resultados, consumen argumentos sin devolver resultados, o suministran resultados sin tomar argumentos, respectivamente. Estas interfaces son esenciales para la programación funcional en Java y se pueden combinar con predicados para crear código más flexible y reutilizable.

Function<T, R>

La interfaz Function<T, R> representa una función que toma un argumento de tipo T y devuelve un resultado de tipo R. Por ejemplo:

import java.util.function.Function;

public class FunctionEjemplo {
    public static void main(String[] args) {
        Function<Integer, String> convertirAString = numero -> "Número: " + numero;
        
        System.out.println(convertirAString.apply(10)); // Número: 10
    }
}

Consumer

La interfaz Consumer<T> representa una función que toma un argumento de tipo T y no devuelve ningún resultado. Por ejemplo:

import java.util.function.Consumer;

public class ConsumerEjemplo {
    public static void main(String[] args) {
        Consumer<String> imprimir = mensaje -> System.out.println(mensaje);
        
        imprimir.accept("Hola, mundo!"); // Hola, mundo!
    }
}

Supplier

La interfaz Supplier<T> representa una función que no toma argumentos y devuelve un resultado de tipo T. Por ejemplo:

import java.util.function.Supplier;

public class SupplierEjemplo {
    public static void main(String[] args) {
        Supplier<String> suministrarMensaje = () -> "Mensaje suministrado";
        
        System.out.println(suministrarMensaje.get()); // Mensaje suministrado
    }
}

Conclusión

Los predicados simples y compuestos son herramientas poderosas en Java para evaluar condiciones y tomar decisiones en el código. Las interfaces funcionales como Predicate, BiPredicate, Function, Consumer y Supplier permiten trabajar con funciones de manera flexible y expresiva, facilitando la programación funcional en Java. Al combinar predicados simples con operadores lógicos, podemos crear condiciones más complejas de manera clara y legible, mejorando la calidad y mantenibilidad del código.