Prédicat Java avec exemples

Généralement, prédicat signifie une déclaration qui détermine si une valeur peut être vraie ou fausse. En programmation, les prédicats désignent des fonctions à un argument qui renvoient une valeur booléenne. Le prédicat d'interface fonctionnelle a été réalisé en Java 8. "Fonctionnel" signifie qu'il ne contient qu'une seule méthode abstraite. Il accepte un argument et renvoie un booléen. En Java, les interfaces fonctionnelles sont utilisées pour gérer les expressions Lambda, les constructeurs et les références de méthode. Habituellement, le prédicat Java 8 est utilisé pour appliquer un filtre à une collection d'objets. Jetons un coup d'œil à ses principales applications et à ses méthodes largement utilisées, ainsi qu'à la résolution de certains problèmes pratiques.

Pourquoi les développeurs utilisent Predicate

Fondamentalement, les développeurs peuvent utiliser des prédicats pour toutes les tâches qui impliquent d'évaluer des éléments en fonction de critères prédéfinis et de renvoyer une valeur booléenne. Voici des exemples de tâches simples que les développeurs gèrent à l'aide de prédicats :

• Filtrer un ensemble d'entiers.
• Trier les listes en s'assurant que les données sont conformes à plusieurs conditions prédéfinies (par exemple organiser une gamme d'articles en fixant des conditions de prix et de poids).
• Utilisation de packages utilitaires dans la programmation concurrente.

Les prédicats sont une fonctionnalité importante dans les tests de logiciels. L'interface fonctionnelle facilite la séparation des unités pour les tests, améliore la lisibilité et la gérabilité du code de l'application.

Syntaxe des prédicats en Java

java.util.function.Predicate a été introduit dans Java 8 comme un autre moyen de gérer les impressions d'évaluation dans Lambda. La vue standard de l'interface est Predicate<T> , où T est un argument unique renvoyant une valeur booléenne. Les prédicats Java ont une méthode fonctionnelle (abstraite) test(Object) qui évalue ce prédicat sur un objet donné.

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

Voici un exemple d'écriture d'un prédicat simple qui filtre les entiers en fonction des conditions "supérieur à", "inférieur à".

// 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 sortie sera vraie car 10 < 18. Un autre exemple avec Predicate dans filter() . Le prédicat aide à filtrer tous les adultes de la liste des âges.

  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 sortie est :

Méthodes de prédicat Java 8

L'interface de prédicat a une poignée de méthodes.

• booléen test(T t) évalue le prédicat sur l'argument donné.
• default Predicate<T> and(Predicate<? super T> other) renvoie un prédicat qui représente un ET logique court-circuitant ce prédicat et un autre.
• default Predicate<T> ou renvoie un prédicat composé qui représente un OU logique court-circuitant ce prédicat et un autre.
• default Predicate<T> negate() renvoie un prédicat qui est logiquement opposé à ce prédicat.
• default Predicate<T> isEqual(Object targetRef) renvoie un résultat de test si deux arguments sont égaux selon Objects.equals(Object, Object) .

test booléen(T t)

Il s'agit d'une méthode fonctionnelle pour les prédicats Java qui évalue si un argument donné satisfait ou non la condition d'un prédicat. Exemple : ici, nous créons un prédicat adulte pour toute personne âgée de 18 ans ou plus. La méthode test() obtient une valeur entière et la vérifie.

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));
   }
}

Quelle sera la sortie du code ci-dessus ? Dans le premier cas, puisque 12 est inférieur à 18, ce sera faux. Quant au deuxième et au troisième scénario, les conditions sont remplies pour que le rendement soit vrai.

Prédicat par défaut.and()

Cette méthode représente l'opérateur "et". C'est pourquoi, si l'un des prédicats donnés ne respecte pas une condition définie, un autre ne recevra pas d'évaluation. Exemple : Composons des prédicats en Java, en filtrant toutes les personnes déjà adultes mais de moins de 65 ans en utilisant and() . Utilisons predicate.add () et écrivons un prédicat java avec lambda pour ces conditions : si la condition est vraie, l'application renverra l'instruction suivante :

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 sortie est :

Prédicat par défaut.ou()

La méthode Predicate.or() représente l'opérateur "OR". Cela signifie que la condition restera vraie même si l'un des deux prédicats est vrai et l'autre est faux. Exemple : évaluons maintenant les chaînes de caractères. Essayez d'utiliser la méthode OR pour trier toutes les phrases qui contiennent la sous-chaîne "my" ou "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 sortie est :

Prédicat par défaut negate()

La méthode negate() est utilisée pour rassembler toutes les valeurs qui ne respectent pas les critères prédéfinis. Exemple : si vous souhaitez trier la classe "Tomates" et trouver toutes les entrées qui ne sont pas "Rouge", vous pouvez écrire un prédicat et parcourir rapidement toute la séquence. Essayez d'écrire vous-même le code de celui-ci et comparez-le à la solution une fois que vous avez terminé.

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 sortie est :

Prédicat statique isEqual(Object targetRef)

Cette méthode est très utile si vous voulez déterminer si deux objets sont égaux à une valeur définie comme paramètre de Objects.equals(). Cette méthode est particulièrement utile si vous devez comparer des résultats de tests similaires. Exemple : disons que vous comparez deux chariots de poires et que vous voulez vous assurer que les deux ont des fruits d'un poids et d'une couleur standard. Dans ce cas, static Predicate isEqual(Object targetRef) est exactement la méthode dont vous avez besoin. Voyons comment isEqual vérifie l'égalité de deux chaînes :

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 objet que vous analysez est conforme aux conditions standard, la fonction renverra true. La sortie est :

Java IntPredicate

Java IntPredicate est une interface fonctionnelle, vous pouvez donc l'utiliser comme cible d'affectation pour une expression lambda ou une référence de méthode. IntPredicate fonctionne sur un entier et renvoie une valeur de prédicat basée sur une condition. Comme Predicate Interface, IntPredicate a également des méthodes test() , and() , negate() ou () . Voici un exemple de IntPredicate. Il filtre également tous les adultes (18 ans ou plus) du tableau.

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 sortie est :

Écrire des prédicats propres en Java

Les prédicats Java sont très fonctionnels et amusants à utiliser. Cependant, à moins que vous ne soyez conscient de l'impact des expressions lambda que vous écrivez sur le code, il existe un risque de réduire la maintenabilité du code avec des prédicats désordonnés. Voici quelques pratiques simples qui vous aideront à vous assurer que vos interfaces fonctionnelles sont faciles à gérer et à lire.

• Ne vous répétez pas — ne composez pas de prédicats avec Java avec des valeurs, des méthodes et des conditions répétées plus d'une fois. De cette façon, vous perdez votre temps productif et rendez le code désordonné.
• Séparez les prédicats du code de l'application pour garantir la testabilité. En dehors de cela, créez un calendrier de tests unitaires de prédicat et respectez-le.
• Utilisez les importations et les modèles de composition pour vous assurer que vos classes ne sont pas gonflées et restent faciles à gérer.
• Envisagez de déplacer les prédicats Java vers les classes Helper — de cette façon, vous améliorez la réutilisabilité de votre code et facilitez la maintenance.
• Lisibilité - dans la mesure du possible, préférez les instructions d'une ligne aux prédicats complexes. Il peut être tentant de montrer votre compréhension des interfaces fonctionnelles complexes. Cependant, en matière d'entretien, moins c'est plus.