Predicado de Java 8 con ejemplos

Una interfaz funcional es una interfaz que permite solo un método abstracto dentro del alcance de la interfaz. Hay algunas interfaces funcionales predefinidas en Java como predicado, consumidor, proveedor, etc. El tipo de devolución de una función Lambda (introducida en JDK 1.8) también es una interfaz funcional.

El PREDICADO de interfaz funcional se define en el paquete java.util.Function . Mejora la capacidad de administración del código, ayuda a probarlos por separado y contiene algunos métodos como:

1. isEqual(Object targetRef) : Devuelve un predicado que comprueba si dos argumentos son iguales según Objects.equals(Object, Object).

   static  Predicate isEqual(Object targetRef)
   Returns a predicate that tests if two arguments are 
   equal according to Objects.equals(Object, Object).
   T : the type of arguments to the predicate
   Parameters:
   targetRef : the object reference with which to 
   compare for equality, which may be null
   Returns: a predicate that tests if two arguments 
   are equal according to Objects.equals(Object, Object)
   

2. and(Predicate other) : Devuelve un predicado compuesto que representa un AND lógico de cortocircuito de este predicado y otro.

   default Predicate and(Predicate other)
   Returns a composed predicate that represents a 
   short-circuiting logical AND of this predicate and another.
   Parameters:
   other: a predicate that will be logically-ANDed with this predicate
   Returns : a composed predicate that represents the short-circuiting 
   logical AND of this predicate and the other predicate
   Throws: NullPointerException - if other is null

3. negate() : Devuelve un predicado que representa la negación lógica de este predicado.

   default Predicate negate()
   Returns:a predicate that represents the logical 
   negation of this predicate

4. or(Predicate other) : Devuelve un predicado compuesto que representa un OR lógico de cortocircuito entre este predicado y otro.

   default Predicate or(Predicate other)
   Parameters:
   other : a predicate that will be logically-ORed with this predicate
   Returns:
   a composed predicate that represents the short-circuiting 
   logical OR of this predicate and the other predicate
   Throws : NullPointerException - if other is null

5. test(T t) : Evalúa este predicado en el argumento dado. boolean test(T t)

   test(T t) 
   Parameters:
   t - the input argument
   Returns:
   true if the input argument matches the predicate, otherwise false

Ejemplos

Ejemplo 1: predicado simple

// Java program to illustrate Simple Predicate
  
import java.util.function.Predicate;
public class PredicateInterfaceExample1 {
    public static void main(String[] args)
    {
        // Creating predicate
        Predicate<Integer> lesserthan = i -> (i < 18); 
  
        // Calling Predicate method
        System.out.println(lesserthan.test(10)); 
    }
}

Producción:

True

Ejemplo 2: Enstringmiento de predicados

// Java program to illustrate Predicate Chaining
  
import java.util.function.Predicate;
public class PredicateInterfaceExample2 {
    public static void main(String[] args)
    {
        Predicate<Integer> greaterThanTen = (i) -> i > 10;
  
        // Creating predicate
        Predicate<Integer> lowerThanTwenty = (i) -> i < 20; 
        boolean result = greaterThanTen.and(lowerThanTwenty).test(15);
        System.out.println(result);
  
        // Calling Predicate method
        boolean result2 = greaterThanTen.and(lowerThanTwenty).negate().test(15);
        System.out.println(result2);
    }
}

Producción:

True
False

Ejemplo 3: predicado en función

// Java program to illustrate 
// passing Predicate into function
  
import java.util.function.Predicate;
class PredicateInterfaceExample3 {
    static void pred(int number, Predicate<Integer> predicate)
    {
        if (predicate.test(number)) {
            System.out.println("Number " + number);
        }
    }
    public static void main(String[] args)
    {
        pred(10, (i) -> i > 7);
    }
}

Producción:

Number 10

Ejemplo 4: Predicado O

// Java program to illustrate OR Predicate
  
import java.util.function.Predicate;
class PredicateInterfaceExample4 {
    public static Predicate<String> hasLengthOf10 = new Predicate<String>() {
        @Override
        public boolean test(String t)
        {
            return t.length() > 10;
        }
    };
  
    public static void predicate_or()
    {
  
        Predicate<String> containsLetterA = p -> p.contains("A");
        String containsA = "And";
        boolean outcome = hasLengthOf10.or(containsLetterA).test(containsA);
        System.out.println(outcome);
    }
    public static void main(String[] args)
    {
        predicate_or();
    }
}

Producción:

True

Ejemplo 5: Predicado Y

// Java program to illustrate AND Predicate
  
import java.util.function.Predicate;
import java.util.Objects;
  
class PredicateInterfaceExample5 {
    public static Predicate<String> hasLengthOf10 = new Predicate<String>() {
        @Override
        public boolean test(String t)
        {
            return t.length() > 10;
        }
    };
  
    public static void predicate_and()
    {
        Predicate<String> nonNullPredicate = Objects::nonNull;
  
        String nullString = null;
  
        boolean outcome = nonNullPredicate.and(hasLengthOf10).test(nullString);
        System.out.println(outcome);
  
        String lengthGTThan10 = "Welcome to the machine";
        boolean outcome2 = nonNullPredicate.and(hasLengthOf10).
        test(lengthGTThan10);
        System.out.println(outcome2);
    }
    public static void main(String[] args)
    {
        predicate_and();
    }
}

Producción:

False
True

Ejemplo 6: Predicado negar()

// Java program to illustrate 
// negate Predicate
  
import java.util.function.Predicate;
class PredicateInterfaceExample6 {
    public static Predicate<String> hasLengthOf10 = new Predicate<String>() {
        @Override
        public boolean test(String t)
        {
            return t.length() > 10;
        }
    };
  
    public static void predicate_negate()
    {
  
        String lengthGTThan10 = "Thunderstruck is a 2012 children's "
                                + "film starring Kevin Durant";
  
        boolean outcome = hasLengthOf10.negate().test(lengthGTThan10);
        System.out.println(outcome);
    }
    public static void main(String[] args)
    {
        predicate_negate();
    }
}

Producción:

False

Ejemplo 7: predicado en colección

// Java program to demonstrate working of predicates
// on collection. The program finds all admins in an
// arrayList of users.
import java.util.function.Predicate;
import java.util.*;
class User
{
    String name, role;
    User(String a, String b) {
        name = a;
        role = b;
    }
    String getRole() { return role; }
    String getName() { return name; }    
    public String toString() {
       return "User Name : " + name + ", Role :" + role;
    }
  
    public static void main(String args[])
    {      
        List<User> users = new ArrayList<User>();
        users.add(new User("John", "admin"));
        users.add(new User("Peter", "member"));
        List admins = process(users, (User u) -> u.getRole().equals("admin"));
        System.out.println(admins);
    }
  
    public static List<User> process(List<User> users, 
                            Predicate<User> predicate)
    {
        List<User> result = new ArrayList<User>();
        for (User user: users)        
            if (predicate.test(user))            
                result.add(user);
        return result;
    }
}

Producción:

[User Name : John, Role :admin]

La misma funcionalidad también se puede lograr utilizando Stream API
y las funciones lambda que se ofrecen desde JDK 1.8 además de Collections API.

La API Stream permite la «transmisión» de colecciones para el procesamiento dinámico. Los flujos permiten el cálculo simultáneo y paralelo de los datos (usando iteraciones internas), para admitir operaciones similares a las de una base de datos, como agrupar y filtrar los datos (similar a la cláusula GROUP BY y WHERE en SQL). Esto permite a los desarrolladores centrarse en «qué datos se necesitan» en lugar de «cómo se necesitan los datos», ya que la transmisión oculta los detalles de la implementación y proporciona el resultado. Esto se hace proporcionando predicados como entradas a las funciones que operan en tiempo de ejecución sobre los flujos de colecciones. En el siguiente ejemplo, ilustramos cómo se puede usar Stream API junto con predicados para filtrar las colecciones de datos como se logró en el Ejemplo 7.

// Java program to demonstrate working of predicates
// on collection. The program finds all admins in an
// arrayList of users.
import java.util.function.Predicate;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
  
class User
{
    String name, role;
    User(String a, String b) {
        name = a;
        role = b;
    }
    String getRole() { return role; }
    String getName() { return name; } 
    public String toString() {
    return "User Name : " + name + ",
    Role :" + role;
    }
  
    public static void main(String args[])
    { 
        List<User> users = 
            new ArrayList<User>();
        users.add(new User("John", "admin"));
        users.add(new User("Peter", "member"));
          
    // This line uses Predicates to filter
    // out the list of users with the role "admin".
    // List admins = process(users, (User u) -> 
    // u.getRole().equals("admin"));
  
    // Replacing it with the following line 
    // using Stream API and lambda functions 
    // produces the same output
      
    // the input to the filter() is a lambda 
    // expression that returns a predicate: a 
    // boolean value for each user encountered 
    // (true if admin, false otherwise)
    List admins = users.stream()
    .filter((user) -> user.getRole().equals("admin"))
    .collect(Collectors.toList());
          
    System.out.println(admins);
    }
}

Producción:

[User Name : John, Role :admin]