Le Tutoriel de Java Predicate

Predicate
Predicate + Method reference
negate()
and(Predicate other)
or(Predicate other)
isEqual(Object targetRef)

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.

Le Tutoriel de Java Functional Interface

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:

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

BiPredicate
IntPredicate
LongPredicate
DoublePredicate
Supplier
Consumer
BiConsumer
Function
BiFunction

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

Le Tutoriel de Java Stream

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

Le Tutoriel de Java Stream

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 Predicateactuel 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

Le Tutoriel de Java Predicate

1. Predicate

2. Predicate + Method reference

3. negate()

4. and(Predicate other)

5. or(Predicate other)

6. isEqual(Object targetRef)

Java Basic

Java Basic

Articles les plus récents