¿Qué es Java Predicate? Conoce su función y cómo aplicarlo

Para que logres una excelente precisión a la hora de crear condiciones y filtrar datos, o logres reducir la tarea de escribir código, pero aún así obtener mejores resultados, tenemos para ti un poderoso concepto denominado: Java Predicate. Sigue leyendo porque en este post te contaremos cuál es su función y cómo puedes aplicar los predicados para transformar la manera en que programas.

¿Qué es un Java Predicate?

Un Java Predicate es, básicamente, una herramienta que te permite definir una condición que debe cumplirse. Piénsalo como una especie de filtro que acepta un valor, lo analiza y devuelve true o false dependiendo de si ese valor cumple con la condición que has establecido. Es muy similar a una función, solo que su principal tarea es verificar si algo es cierto o no.

Este predicado es muy popular cuando trabajas con colecciones o Streams en Java, porque puedes aplicar reglas específicas para filtrar datos. Todo esto es gracias a su único método llamado test, que recibe un objeto, lo evalúa y te dice si cumple con la condición que tú hayas definido.

Ejemplo de un Java Predicate

En este contexto, tienes una lista de empleados y necesitas filtrar aquellos que ganan más de 50,000 euros al año. Entonces, puedes definir un predicado para que verifique esa condición y lo aplique sobre la lista, así:

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

class Empleado {
    private String nombre;
    private double salario;

    public Empleado(String nombre, double salario) {
        this.nombre = nombre;
        this.salario = salario;
    }

    public String getNombre() {
        return nombre;
    }

    public double getSalario() {
        return salario;
    }
}

public class Principal {
    public static void main(String[] args) {
        List<Empleado> empleados = new ArrayList<>();
        empleados.add(new Empleado("Ana", 45000));
        empleados.add(new Empleado("Luis", 60000));
        empleados.add(new Empleado("Marta", 55000));

        // Crear el Predicate
        Predicate<Empleado> salarioAlto = empleado -> empleado.getSalario() > 50000;

        // Aplicar el Predicate para filtrar empleados con salario alto
        empleados.stream()
                 .filter(salarioAlto)
                 .forEach(empleado -> System.out.println(empleado.getNombre() + " tiene un salario mayor a 50,000 euros."));
    }
}

Lo que sucedió fue que, Java Predicate definió una condición simple: verificar si el salario de un empleado es mayor a 50,000 euros. De modo que, al aplicar el predicado sobre el stream de empleados, obtuvimos aquellos que sí cumplían con dicha condición.

Luis tiene un salario mayor a 50,000 euros.
Marta tiene un salario mayor a 50,000 euros.

Cómo aplicar Java Predicate en tus proyectos

La idea es que aprendas a aplicar Java Predicate en situaciones cotidianas dentro de proyectos en Java. Generalmente, un predicado se usa para filtrar datos de colecciones como listas o arrays. Aunque, también lo puedes usar para validar entradas, realizar búsquedas o simplificar condiciones complejas dentro de tu lógica de negocio.

Ventajas del uso de predicados

1. Código más limpio: Como se usan expresiones Lambda, puedes usar predicados para escribir condiciones en una sola línea, haciendo tu código más conciso y fácil de leer.
2. Reutilización: Los predicados son muy reutilizables. Puedes definir un predicado que valide una condición y usarlo en diferentes partes de tu aplicación.
3. Integración con Streams: Los predicados funcionan de maravilla con los Streams, lo que te permite procesar y filtrar colecciones de datos de forma eficiente.

Expresiones Lambda y Predicados

Anteriormente ya usamos Java Predicate con una expresión Lambda con la cual se definió una condición. Recuerda que estas expresiones ayudan a representar los métodos funcionales de una manera más simplificada. Entonces, si buscas escribir el mismo predicado sin una expresión lambda, te quedaría más extenso.

Predicate<Empleado> salarioAlto = new Predicate<Empleado>() {
    @Override
    public boolean test(Empleado empleado) {
        return empleado.getSalario() > 50000;
    }
};

En cambio, con la expresión Lambda obtendrías algo así:

Predicate<Empleado> salarioAlto = empleado -> empleado.getSalario() > 50000;

Como ves, obtienes un resultado similar, pero con una estructura más sencilla.

Usos avanzados de Java Predicate

Dentro de los usos que le puedes dar a Java Predicate también está el de combinarlo para formar condiciones más complejas. Estas son algunas operaciones:

• and(): Combina dos predicados y devuelve true solo si ambos predicados son verdaderos.
• or(): Devuelve true si al menos uno de los predicados es verdadero.
• negate(): Devuelve el opuesto del predicado original (invierte el resultado booleano).

De modo que, si quieres encontrar empleados que ganan más de 50,000 euros o que se llamen “Ana”, esto es lo que puedes hacer:

Predicate<Empleado> salarioAlto = empleado -> empleado.getSalario() > 50000;
Predicate<Empleado> nombreAna = empleado -> empleado.getNombre().equals("Ana");

empleados.stream()
         .filter(salarioAlto.or(nombreAna))
         .forEach(empleado -> System.out.println(empleado.getNombre()));

El resultado sería:

Ana
Luis
Marta

La combinación de Java Predicate con expresiones lambda y streams te facilitará las operaciones de filtrado y, además, simplificarás tu código mejorando su legibilidad y sostenibilidad a largo plazo.

Continúa con tu formación con nuestro Bootcamp Java Full Stack de KeepCoding. Con nosotros no solo lograrás manejar a la perfección los predicados, sino que también te prepararás para enfrentar los retos del sector IT. Anímate a ingresar a un sector donde todos los días requieren profesionales altamente capacitados para brindarles excelentes salarios y estabilidad laboral. ¡Apúntate hoy y transforma tu vida con un futuro lleno de oportunidades, altos salarios y estabilidad laboral que otros sectores no ofrecen!