devstory

Le Tutoriel de Java BiPredicate

View more Tutorials:

1- BiPredicate

Dans Java 8, BiPredicate est une functional interface, qui représente un opérateur lequel accepte deux paramètres d'entrée et renvoie une valeur boolean.
BiPredicate interface
@FunctionalInterface
public interface BiPredicate<T, U> {
    boolean test(T t, U u);
    
    default BiPredicate<T, U> and(BiPredicate<? super T, ? super U> other) {
        Objects.requireNonNull(other);
        return (T t, U u) -> test(t, u) && other.test(t, u);
    }  
    default BiPredicate<T, U> negate() {
        return (T t, U u) -> !test(t, u);
    }
    default BiPredicate<T, U> or(BiPredicate<? super T, ? super U> other) {
        Objects.requireNonNull(other);
        return (T t, U u) -> test(t, u) || other.test(t, u);
    }
}
Voir aussi: Predicate est une functional interface similaire à BiPredicate, qui n'accepte qu'un seul paramètre:
Exemple: Créer un objet BiPredicate pour vérifier si la longueur d'une String correspond à un nombre donné.
BiPredicateEx1.java
package org.o7planning.bipredicate.ex;

import java.util.function.BiPredicate;

public class BiPredicateEx1 {

    public static void main(String[] args) {  
        // Create a BiPredicate.
        BiPredicate<String,Integer> tester = (aString, aNumber) -> {
            return aString.length() == aNumber;
        };
        // Test:
        boolean testResult = tester.test("o7planning.org", 14);
        
        System.out.println("Test Result: " + testResult);
    }
}
Output:
Test Result: true
Consulter l'exemple ci-dessus. Un objet Map<String,Integer> contient des mappages entre une String et sa longueur. Cependant, il existe des mappages incorrects. Imprimer les mappages corrects.
BiPredicateEx2.java
package org.o7planning.bipredicate.ex;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiPredicate;

public class BiPredicateEx2 {

    public static void main(String[] args) {  
        // Create a BiPredicate.
        BiPredicate<String,Integer> tester = (aString, aNumber) -> {
            return aString.length() == aNumber;
        };

        // String aString --> Integer length.
        Map<String,Integer> map = new HashMap<String,Integer>();
        
        map.put("Apple", 5);
        map.put("Google", 10); // Wrong
        map.put("Microsoft", 9);
        map.put("Amazon", 100); // Wrong
        map.put("Louis Vuitton", 13);  
        map.put("Disney", 6);  
        map.put("Intel", 5);  
        
        map.entrySet()  // Set<Map.Entry<String,Integer>>
             .stream()  // Stream<Map.Entry<String,Integer>>
             // filter(Predicate<Map.Entry<String,Integer>>)
             .filter(entry ->  tester.test(entry.getKey(), entry.getValue())) // Stream<Map.Entry<String,Integer>>
             .forEach(entry -> System.out.println(entry.getKey() +" --> " + entry.getValue()));
    }
}
Output:
Apple --> 5
Disney --> 6
Louis Vuitton --> 13
Microsoft --> 9
Intel --> 5

2- test(T t, U u)

public boolean test(T t, U u);
Évaluer ce BiPredicate sur les arguments donnés.

3- BiPredicate + Method reference

Si une méthode statique prend 2 paramètres et renvoie un boolean, alors sa référence est considérée comme un BiPredicate:
Par exemple:
BiPredicate_mRef_ex1.java
package org.o7planning.bipredicate.ex;

import java.util.function.BiPredicate;

public class BiPredicate_mRef_ex1 {

    public static void main(String[] args) {
        // Create a BiPredicate from a Method reference.
        BiPredicate<Staff,Integer> tester = StaffUtils::higher;
        
        Staff tom = new Staff("Tom", 3000);
        
        boolean testResult = tester.test(tom, 2000);
        
        System.out.println("Test Result: " + testResult);
    }
}

class StaffUtils {

    // A static method take 2 input parameters and return boolean type.
    public static boolean higher(Staff staff, int salary) {
         return staff.getSalary() > salary;
    }
}

class Staff {
    private String fullName;
    private int salary;
    
    public Staff(String fullName, int salary) {
        this.fullName = fullName;
        this.salary = salary;
    }
    public String getFullName() {
        return fullName;
    }
    public int getSalary() {
        return salary;
    }
}
Output:
Test Result: true

4- negate()

negate() renvoie un nouvel objet BiPredicate dont l'évaluation est négative du BiPredicate actuel.
default BiPredicate<T, U> negate() {
    return (T t, U u) -> !test(t, u);
}
Exemple: Un BiPredicate<Integer,Integer> qui vérifie 2 chiffres pour vérifier si le premier est supérieur au deuxième.
BiPredicate_negate_ex1.java
package org.o7planning.bipredicate.ex;

import java.util.function.BiPredicate;

public class BiPredicate_negate_ex1 {

    public static void main(String[] args) {  
        // Create a BiPredicate.
        // Check if anInteger1 > anInteger2
        BiPredicate<Integer, Integer> tester = (anInteger1, anInteger2) -> {
            return anInteger1 > anInteger2;
        };
      
        boolean test1 = tester.test(100, 10);
        
        boolean test2 = tester.negate().test(100, 10);
   
        System.out.println("Test1: " + test1);
        System.out.println("Test2: " + test2);
    }
}
Output:
Test1: true
Test2: false
Exemple: Un objet Map<String,Integer> contient des mappages entre une String et sa longueur. Cependant, il existe des mappages incorrects. Imprimer ces mappages incorrects.
BiPredicate_negate_ex2.java
package org.o7planning.bipredicate.ex;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiPredicate;

public class BiPredicate_negate_ex2 {

    public static void main(String[] args) {  
        // Create a BiPredicate.
        // Check if length of a String equals to aNumber.
        BiPredicate<String,Integer> tester = (aString, aNumber) -> {
            return aString.length() == aNumber;
        };

        // String aString --> Integer length.
        Map<String,Integer> map = new HashMap<String,Integer>();
        
        map.put("Apple", 5);
        map.put("Google", 10); // Wrong
        map.put("Microsoft", 9);
        map.put("Amazon", 100); // Wrong
        map.put("Louis Vuitton", 13);  
        map.put("Disney", 6);  
        map.put("Intel", 5);  
        
        map.entrySet()  // Set<Map.Entry<String,Integer>>
             .stream()  // Stream<Map.Entry<String,Integer>>
             // filter(Predicate<Map.Entry<String,Integer>>)
             .filter(entry ->  tester.negate().test(entry.getKey(), entry.getValue())) // Stream<Map.Entry<String,Integer>>
             .forEach(entry -> System.out.println(entry.getKey() +" --> " + entry.getValue()));
    }
}
Output:
Google --> 10
Amazon --> 100

5- and(BiPredicate other)

La méthode and(other) crée un nouvel objet BiPredicate en combinant le BiPredicate actuel et other. Il est évalué comme true si le BiPredicate actuel et other sont évalués comme true.
default BiPredicate<T, U> and(BiPredicate<? super T, ? super U> other) {
    Objects.requireNonNull(other);
    return (T t, U u) -> test(t, u) && other.test(t, u);
}
Par exemple:
BiPredicate_and_ex1.java
package org.o7planning.bipredicate.ex;

import java.util.function.BiPredicate;

public class BiPredicate_and_ex1 {

    public static void main(String[] args) {
        // Test if anInteger1 > anInteger2
        BiPredicate<Integer, Integer> tester1 = (anInteger1, anInteger2) -> {
            return anInteger1 > anInteger2;
        };

        // Test if anInteger1 + anInteger2 > 100
        BiPredicate<Integer, Integer> tester2 = (anInteger1, anInteger2) -> {
            return anInteger1 + anInteger2 > 100;
        };

        // Test if number1 > number2 and number1 + number2 > 100.
        boolean testResult1 = tester1.and(tester2).test(70, 45);
        boolean testResult2 = tester1.and(tester2).test(45, 70);
        
        System.out.println("Test Result 1: " + testResult1);
        System.out.println("Test Result 2: " + testResult2);
    }
}
Output:
Test Result 1: true
Test Result 2: false

6- or(BiPredicate other)

La méthode or(other) renvoie un nouvel objet BiPredicate en combinant le BiPredicate actuel et other. Il est évalué comme true si l'un ou l'autre, le BiPredicate actuel ou other est évalué comme true.
default BiPredicate<T, U> or(BiPredicate<? super T, ? super U> other) {
    Objects.requireNonNull(other);
    return (T t, U u) -> test(t, u) || other.test(t, u);
}
Par exemple:
BiPredicate_or_ex1.java
package org.o7planning.bipredicate.ex;

import java.util.function.BiPredicate;

public class BiPredicate_or_ex1 {

    public static void main(String[] args) {
        // Test if anInteger1 > anInteger2
        BiPredicate<Integer, Integer> tester1 = (anInteger1, anInteger2) -> {
            return anInteger1 > anInteger2;
        };

        // Test if anInteger1 + anInteger2 > 100
        BiPredicate<Integer, Integer> tester2 = (anInteger1, anInteger2) -> {
            return anInteger1 + anInteger2 > 100;
        };

        // Test if number1 > number2 or number1 + number2 > 100.
        boolean testResult1 = tester1.or(tester2).test(70, 45);
        boolean testResult2 = tester1.or(tester2).test(45, 70);  
        
        System.out.println("Test Result 1: " + testResult1);
        System.out.println("Test Result 2: " + testResult2);
    }
}
Output:
Test Result 1: true
Test Result 2: true

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.