Predicado de Java con ejemplos

Generalmente predicado significa una declaración que determina si un valor puede ser verdadero o falso. En la programación, los predicados significan funciones con un argumento que devuelven un valor booleano. El predicado de interfaz funcional se realizó en Java 8. "Funcional" significa que contiene solo un método abstracto. Acepta un argumento y devuelve un valor booleano. En Java, las interfaces funcionales se utilizan para manejar expresiones Lambda, constructores y referencias de métodos. Por lo general, Java 8 Predicate se usa para aplicar un filtro para una colección de objetos. Echemos un vistazo a sus principales aplicaciones y métodos ampliamente utilizados, además de resolver algunos problemas prácticos.

Por qué los desarrolladores usan predicado

Básicamente, los desarrolladores pueden usar predicados para cualquier tarea que implique evaluar elementos en función de criterios predefinidos y devolver un valor booleano. Aquí están los ejemplos de tareas simples que los desarrolladores manejan usando predicados:

• Filtrado de un conjunto de enteros.
• Ordenar listas asegurándose de que los datos cumplan con varias condiciones predefinidas (p. ej., organizar una gama de artículos estableciendo condiciones de precio y peso).
• Uso de paquetes de utilidades en programación concurrente.

Los predicados son una característica importante en las pruebas de software. La interfaz funcional facilita la separación de unidades para la prueba, mejora la legibilidad y la manejabilidad del código de la aplicación.

Sintaxis de predicados en Java

java.util.function.Predicate se introdujo en Java 8 como una forma alternativa de manejar las impresiones de evaluación en Lambda. La vista estándar de la interfaz es Predicate<T> , donde T es un único argumento que devuelve un valor booleano. Los predicados de Java tienen una prueba de método funcional (abstracto) (objeto) que evalúa este predicado en un objeto dado.

@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
}

Aquí hay un ejemplo de cómo escribir un Predicado simple que filtra números enteros según las condiciones "mayor que", "menor que".

// An example of a simple Java predicate
  
import java.util.function.Predicate; 
public class PredicateExample { 
    public static void main(String[] args) 
    { 
        // Creating predicate 
        Predicate<Integer> lesserThan = i -> (i < 18);  
  
        // Calling Predicate method 
        System.out.println(lesserThan.test(10));  
    }
}

La salida será verdadera porque 10 < 18. Un ejemplo más con Predicate en filter() . Predicate ayuda a filtrar todos los adultos de la lista de edades.

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

  public class PredicateExample {
      public static void main(String[] args) {
          List<Integer> ages = List.of(17, 18, 19, 28, 18, 28, 46, 7, 8, 9, 21, 12);
          NotLessThan18<Integer> isAdult = new NotLessThan18<>();
          ages.stream().filter(isAdult).forEach(System.out::println);
      }
  }



class NotLessThan18<E> implements Predicate<Integer> {

      @Override
      public boolean test(Integer v) {
          Integer ADULT = 18;
          return v >= ADULT;
      }
  }

La salida es:

Métodos de predicado de Java 8

La interfaz de predicado tiene un puñado de métodos.

• boolean test(T t) evalúa el predicado en el argumento dado.
• default Predicate<T> and(Predicate<? super T> other) devuelve un predicado que representa un AND lógico de cortocircuito de este predicado y otro.
• predeterminado Predicate<T> o devuelve un predicado compuesto que representa un OR lógico de cortocircuito de este predicado y otro.
• predeterminado Predicate<T> negate() devuelve un predicado que es opuesto a este predicado lógicamente.
• predeterminado Predicate<T> isEqual(Object targetRef) devuelve un resultado de probar si dos argumentos son iguales de acuerdo con Objects.equals(Object, Object) .

prueba booleana (T t)

Este es un método funcional para los predicados de Java que evalúa si un argumento dado satisface o no la condición de un predicado. Ejemplo: aquí creamos un adulto predicado para todos los que tienen 18 años o más. El método test() obtiene un valor entero y lo comprueba.

import java.util.function.Predicate;
public class PredicateTestTest {
   public static void main(String[] args) {
       Predicate<Integer> adult = i -> i >= 18;
       System.out.println(adult.test(12));
       System.out.println(adult.test(19));
       System.out.println(adult.test(21));
   }
}

¿Cuál será el resultado del código anterior? En el primer caso, como 12 es menor que 18, será falso. En cuanto al segundo y tercer escenario, se dan las condiciones para que la devolución sea cierta.

Predicado predeterminado.y()

Este método representa el operador "y". Por eso, si uno de los predicados dados no cumple con una condición establecida, otro no obtendrá una evaluación. Ejemplo: Compongamos predicados en Java, filtrando a todas las personas que ya son adultas pero menores de 65 años usando and() . Usemos predicate.add () y escribamos un predicado java con lambda para estas condiciones: si la condición es verdadera, la aplicación devolverá la siguiente declaración:

import java.util.function.Predicate;

   public class PredicateDemo {
       public static void main(String[] args) {
           Predicate<Integer> adultYet = i -> i >= 18;
           Predicate<Integer> adultStill = i -> i < 65;
           System.out.println(adultYet.and(adultStill).test(5));
           System.out.println(adultYet.and(adultStill).test(38));
           System.out.println(adultYet.and(adultStill).test(90));
       }
   }

La salida es:

Predicado por defecto.or()

El método Predicate.or() representa el operador "OR". Esto significa que la condición seguirá siendo verdadera incluso si uno de los dos predicados es verdadero y el otro es falso. Ejemplo: vamos a evaluar cadenas de caracteres ahora. Intente utilizar el método OR para clasificar todas las frases que contengan la subcadena "my" o "crayon".

import java.util.function.Predicate;

  public class PredicateDemo2 {
      public static void main(String[] args) {
          Predicate<String> containsA = t -> t.contains("crayon");
          Predicate<String> containsB = t -> t.contains("my");
          System.out.println(containsA.or(containsB).test("here is my crayon"));
          System.out.println(containsA.or(containsB).test("here is my pencil"));
          System.out.println(containsA.or(containsB).test("here is John's crayon"));
          System.out.println(containsA.or(containsB).test("here is John's pencil"));
      }
  }

La salida es:

Predicado predeterminado negar ()

El método negate() se usa para recopilar todos los valores que no cumplen con los criterios predefinidos. Ejemplo: si desea ordenar la clase "Tomates" y encontrar todas las entradas que no sean "Rojas", puede escribir un Predicado y escanear rápidamente toda la secuencia. Intenta escribir el código para este por tu cuenta y compáralo con la solución una vez que hayas terminado.

import java.util.function.Predicate;

public class PredicateDemo3 {
public static void main(String[] args) {
 Predicate<Integer> adult = i -> i >= 18;
System.out.println(adult.negate().test(7));  System.out.println(adult.negate().test(19))
  }
   }

La salida es:

El predicado estático es igual (objeto targetRef)

Este método es muy útil si desea determinar si dos objetos son iguales a un valor definido como parámetro de Objects.equals(). Este método es especialmente útil si necesita comparar resultados de pruebas similares. Ejemplo: supongamos que está comparando dos carruajes de peras y quiere asegurarse de que ambos tengan frutas de un peso y color estándar. En este caso, el predicado estático isEqual(Object targetRef) es exactamente el método que necesita. Echemos un vistazo a cómo isEqual verifica la igualdad de dos cadenas:

import java.util.function.Predicate;

public class PredicateDemo2 {
   public static void main(String[] args) {
       Predicate<String> i = Predicate.isEqual("here is my crayon");
       System.out.println(i.test("here is my pencil"));
       System.out.println(i.test("here is my crayon"));
   }
}

Si un objeto que está analizando cumple con las condiciones estándar, la función devolverá verdadero. La salida es:

Java IntPredicate

Java IntPredicate es una interfaz funcional, por lo que puede usarla como destino de asignación para una expresión lambda o una referencia de método. IntPredicate opera en un número entero y devuelve un valor de predicado basado en una condición. Como Predicate Interface, IntPredicate también tiene métodos test() , and() , negate() o () . Aquí hay un ejemplo de IntPredicate. También filtra todos los adultos (18 o más) de la matriz.

import java.util.Arrays;
import java.util.function.IntPredicate;

public class IntPredicateExample {

   public static void main(String[] args) {

       int[] ages = { 18, 28, 18, 46, 90, 45, 2, 3, 1, 5, 7, 21, 12 };

       IntPredicate p = n -> n >= 18;

       Arrays.stream(ages).filter(p).forEach(System.out::println);
   }
}

La salida es:

Escribir predicados limpios en Java

Los predicados de Java son altamente funcionales y divertidos para trabajar. Sin embargo, a menos que tenga en cuenta cómo las expresiones lambda que escribe afectan el código, existe el riesgo de reducir la capacidad de mantenimiento del código con predicados desordenados. Aquí hay algunas prácticas simples que lo ayudarán a garantizar que sus interfaces funcionales sean fáciles de administrar y leer.

• No se repita: no componga predicados con Java con valores, métodos y condiciones repetidos más de una vez. De esta manera, desperdicia su tiempo productivo y ensucia el código.
• Separe los predicados del código de la aplicación para garantizar la capacidad de prueba. Aparte de eso, cree un programa de prueba de unidad de predicado y cúmplalo.
• Utilice importaciones y patrones de composición para asegurarse de que sus clases no estén infladas y sigan siendo fáciles de administrar.
• Considere mover los predicados de Java a las clases auxiliares; de esta manera, mejorará la reutilización de su código y facilitará el mantenimiento.
• Legibilidad: siempre que sea posible, prefiera declaraciones de una línea en lugar de predicados complejos. Puede ser tentador mostrar su comprensión de las interfaces funcionales complejas. Sin embargo, cuando se trata de mantenimiento, menos es más.