devstory

Le Tutoriel de Java Predicate

View more Tutorials:

1- Predicate

Dans Java 8, Predicate est une functional interface, représentant un opérateur qui accepte un paramètre d'entrée et renvoie une valeur boolean.
Predicate
@FunctionalInterface
public interface Predicate<T> {
  boolean test(T t);
}
Exemple: Créer un Predicate pour vérifier si un nombre est impair ou non.
PredicateEx1.java
package org.o7planning.ex;

import java.util.function.Predicate;

public class PredicateEx1 {

    public static void main(String[] args) {
        
        Predicate<Integer> tester = value -> value % 2 == 1;
        
        int value = 11;
        
        System.out.println(value + " Is an Odd Number? " + tester.test(value));
    }
}
Output:
11 Is an Odd Number? true
Predicate est également utilisé pour vérifier si les éléments d'une liste répondent à une certaine condition.
Exemple: Une liste de nombres Integer (entiers), on filtera une nouvelle liste composée uniquement de nombres impairs.
PredicateEx2.java
package org.o7planning.ex;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class PredicateEx2 {

    public static void main(String[] args) {

        Predicate<Integer> tester = value -> value % 2 == 1;

        List<Integer> list = Arrays.asList(10, 11, 13, 14, 15, 16, 17);

        // @see: stream.filter(Predicate)
        List<Integer> newList = list.stream() //
                .filter(tester).collect(Collectors.toList());
 
        // @see: list.forEach(Consumer)
        newList.forEach(System.out::println);
    }
}
Output:
11
13
15
17
Exemple: A partir d'une liste de noms, imprimer uniquement ceux avec "S" comme initial:
PredicateEx3.java
package org.o7planning.ex;

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

public class PredicateEx3 {

    public static void main(String[] args) {

        Predicate<String> tester = name -> name.startsWith("S");

        List<String> names = Arrays.asList("John", "Smith", "Samueal", "Catley", "Sie");

        // @see: stream.filter(Predicate)
        // @see: stream.forEach(Consumer)
        names.stream().filter(tester).forEach(System.out::println);
    }
}
Output:
Smith
Samueal
Sie
  • TODO Link!
  • TODO Link!
  • TODO Link!

2- Predicate + Method reference

Ensuite, on observe des exemples sur la création d'un Predicate à partir d'une référence de méthode. Les classes Employee et EmployeeUtils sont présentes dans ces exemples.
Employee.java
package org.o7planning.ex;

public class Employee {

    private String name;
    private float salary;
    private String gender; // "M", "F"

    public Employee(String name, float salary, String gender) {
        this.name = name;
        this.salary = salary;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public float getSalary() {
        return salary;
    }

    public String getGender() {
        return gender;
    }

    public boolean isFemale() {
        return "F".equals(this.getGender());
    }
}
EmployeeUtils.java
package org.o7planning.ex;

public class EmployeeUtils {
    
    public static boolean isHighSalary(Employee e) {
        return e.getSalary() > 5000;
    }
}

M.ref Example 1:

Si une méthode statique prend un paramètre de type <T> et renvoie un boolean, alors sa référence peut être considérée comme un Predicate<T>:
Exemple: La méthode statique EmployeeUtils.isHighSalary(Employee) est un Predicate<Employee>:
Predicate<Employee> p = EmployeeUtils::isHighSalary;

// Same as:

Predicate<Employee> p = employee -> EmployeeUtils.isHighSalary(employee);
Predicate_mr_ex1.java
package org.o7planning.ex;

import java.util.function.Predicate;

public class Predicate_mr_ex1 {

    public static void main(String[] args) {
        
        Employee sophia = new Employee("Sophia B.", 7000, "F");
        
        // Create a Predicate from a method reference.
        Predicate<Employee> tester = EmployeeUtils::isHighSalary;
        
        System.out.println("High Salary? " + tester.test(sophia));
    }
}
Output:
High Salary? true

M.ref Example 2:

Employee.isFemale() est une méthode non statique, sans paramètre et renvoie un boolean, sa référence est donc considérée comme un Predicate<Employee>:
Predicate<Employee> p = Employee::isFemale;

// Same as:

Predicate<Employee> p = employee -> employee.isFemale();
Predicate_mr_ex2.java
package org.o7planning.ex;

import java.util.function.Predicate;

public class Predicate_mr_ex2 {

    public static void main(String[] args) {
        
        Employee sophia = new Employee("Sophia B.", 7000, "F");
        
        // Create a Predicate from a method reference.
        Predicate<Employee> tester = Employee::isFemale;
        
        System.out.println("High Salary? " + tester.test(sophia));
    }
}
Output:
High Salary? true

3- negate()

La méthode negate() renvoie un nouvel objet Predicate, dont l'évaluation est un négatif du Predicate actuel.
default Predicate<T> negate() {
    return (t) -> !test(t);
}
Exemple: Une liste de nombres Integer (entiers), on filtrera une nouvelle liste contenant uniquement des nombres pairs.
PredicateEx7.java
package org.o7planning.ex;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class PredicateEx7 {

    public static void main(String[] args) {

        
        // Checks if a number is odd.
        Predicate<Integer> tester = value -> value % 2 == 1;

        List<Integer> list = Arrays.asList(10, 11, 13, 14, 15, 16, 17);

        // @see: stream.filter(Predicate)
        List<Integer> newList = list.stream() //
                .filter(tester.negate()).collect(Collectors.toList());
 
        // @see: list.forEach(Consumer)
        newList.forEach(System.out::println);
    }
}
Output:
10
14
16

4- and(Predicate other)

La méthode and(other) crée un nouvel objet Predicate en combinant l'objet Predicate actuel et other. Elle est estimée true si tous les deux Predicate actuel et other sont true.
default Predicate<T> and(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) && other.test(t);
}
Exemple: Une liste de nombres Integer, on filtrera une nouvelle liste composée uniquement de nombres impairs et supérieurs à 20.
PredicateEx8.java
package org.o7planning.ex;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class PredicateEx8 {

    public static void main(String[] args) {

        // Test if a number is odd.
        Predicate<Integer> tester1 = value -> value % 2 == 1;
        // Test if anumber > 20
        Predicate<Integer> tester2 = value -> value > 20;

        List<Integer> list = Arrays.asList(10, 11, 13, 14, 15, 16, 17, 25, 27, 26, 28);

        // A List of odd and greater than 20.
        // @see: stream.filter(Predicate)
        List<Integer> newList = list.stream() //
                .filter(tester1.and(tester2)).collect(Collectors.toList());
 
        // @see: list.forEach(Consumer)
        newList.forEach(System.out::println);
    }
}
Output:
25
27

5- or(Predicate other)

La méthode or(other) renvoie un nouvel objet Predicate en combinant l'objet Predicate actuel et other. Elle est estimée true si le Predicate actuel ou other est true.
default Predicate<T> or(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) || other.test(t);
}
Exemple: Donner une liste de noms, imprimer les noms initiés par "A" ou se terminant par "p".
PredicateEx9.java
package org.o7planning.ex;

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

public class PredicateEx9 {

    public static void main(String[] args) {

        List<String> names = Arrays.asList("Peter", "Martin", "Alex", "Philip", "Piyush", "Mike");

        Predicate<String> tester1 = name -> name.startsWith("A");
        Predicate<String> tester2 = name -> name.endsWith("p");

        // find a name starts with "A" or ends with "p"
        names.stream().filter(tester1.or(tester2)).forEach(System.out::println);
    }
}
Output:
Alex
Philip

6- isEqual(Object targetRef)

La méthode statique Predicate.isEqual(targetRef) renvoie un Predicate pour vérifier si deux objets sont égaux ou non à l'aide de la méthode Objects.equals(Object, Object).
static <T> Predicate<T> isEqual(Object targetRef) {
    return (null == targetRef)
            ? Objects::isNull
            : object -> targetRef.equals(object);
}
PredicateEx10.java
package org.o7planning.ex;

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

public class PredicateEx10 {

    public static void main(String[] args) {

        Predicate<String> test1 = Predicate.isEqual("Mike");
        
        // test1 same as test2:
        Predicate<String> test2 = myIsEqual("Mike");
        
        List<String> names = Arrays.asList(
                "Peter",
                "Martin",
                "Alex",
                "Philip",
                "Piyush",
                "Mike"
               );
             
               
       // Find a name that is equals "Mike"
       names.stream()
            .filter(test1)
            .forEach(System.out::println);
    }

    public static <T> Predicate<T> myIsEqual(Object targetRef) {
        Predicate<T> tester = obj -> Objects.equals(obj, targetRef);
        return tester;
    }
}
Output:
Mike

View more Tutorials:

Peut-être que vous êtes intéressé

Voici des leçons en ligne à part du site web o7planning que nous recommandons. La liste comprend des leçons en ligne et celles en promo.