Predicate en Java

je suppose que vous parlez de com.google.common.base.Predicate<T> de goyave.

de L'API:

détermine une valeur true ou false pour une entrée donnée. Par exemple , un RegexPredicate pourrait implémenter Predicate<String> , et retourner true pour toute chaîne qui correspond à son expression régulière donnée.

C'est essentiellement une OOP abstraction pour un boolean test.

par exemple, vous pouvez avoir une méthode d'aide comme ceci:

static boolean isEven(int num) {
   return (num % 2) == 0; // simple
}

maintenant, avec un List<Integer> , vous pouvez traiter seulement les nombres pairs comme ceci:

    List<Integer> numbers = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
    for (int number : numbers) {
        if (isEven(number)) {
            process(number);
        }
    }

avec Predicate , l'essai if est résumé en tant que type. Cela lui permet d'interopérer avec le reste de L'API, comme Iterables , qui ont de nombreuses méthodes d'utilité qui prend Predicate .

Ainsi, vous pouvez maintenant écrire quelque chose comme ceci:

    Predicate<Integer> isEven = new Predicate<Integer>() {
        @Override public boolean apply(Integer number) {
            return (number % 2) == 0;
        }               
    };
    Iterable<Integer> evenNumbers = Iterables.filter(numbers, isEven);

    for (int number : evenNumbers) {
        process(number);
    }

notez que maintenant la boucle pour chaque boucle est beaucoup plus simple sans le test if . Nous avons atteint un niveau plus élevé d'aberration en définissant Iterable<Integer> evenNumbers , par filter -ing en utilisant un Predicate .

API links

• Iterables.filter
  • renvoie les éléments qui satisfaire un prédicat.

---

sur la fonction d'ordre supérieur

Predicate permet à Iterables.filter de servir ce qu'on appelle une fonction d'ordre supérieur. Sur son propre, ce qui offre de nombreux avantages. Prenez l'exemple List<Integer> numbers ci-dessus. Supposons que nous voulons tester si tous les nombres sont positifs. Nous pouvons écrire quelque chose comme ceci:

static boolean isAllPositive(Iterable<Integer> numbers) {
    for (Integer number : numbers) {
        if (number < 0) {
            return false;
        }
    }
    return true;
}

//...
if (isAllPositive(numbers)) {
    System.out.println("Yep!");
}

avec un Predicate , et en interférant avec le reste des bibliothèques, nous pouvons écrire ceci:

Predicate<Integer> isPositive = new Predicate<Integer>() {
    @Override public boolean apply(Integer number) {
        return number > 0;
    }       
};

//...
if (Iterables.all(numbers, isPositive)) {
    System.out.println("Yep!");
}

espérons que vous pouvez maintenant Voir la valeur dans les abstractions supérieures pour des routines comme "filtrer tous les éléments par le prédicat donné", "vérifier si tous les éléments satisfont le prédicat donné", etc faire pour un meilleur code.

malheureusement Java n'a pas de méthodes de première classe: vous ne pouvez pas passer méthodes autour de Iterables.filter et Iterables.all . Vous pouvez, bien sûr, passer autour de objets en Java. Ainsi, le type Predicate est défini, et vous passez objects implémentant cette interface à la place.

voir aussi

• Wikipedia/fonction d'ordre Supérieur
• Wikipedia/Filtre (fonction d'ordre supérieur)