Passer des paramètres à des Prédicats

J'ai la carte suivante des critères de recherche:

private final Map<String, Predicate> searchMap = new HashMap<>();

private void initSearchMap() {
    Predicate<Person> allDrivers = p -> p.getAge() >= 16;
    Predicate<Person> allDraftees = p -> p.getAge() >= 18
            && p.getAge() <= 25
            && p.getGender() == Gender.MALE;
    Predicate<Person> allPilots = p -> p.getAge() >= 23
            && p.getAge() <=65;

    searchMap.put("allDrivers", allDrivers);
    searchMap.put("allDraftees", allDraftees);
    searchMap.put("allPilots", allPilots);
}

Je suis en utilisant cette carte de la manière suivante:

pl.stream()
    .filter(search.getCriteria("allPilots"))
    .forEach(p -> {
        p.printl(p.getPrintStyle("westernNameAgePhone"));
    });

Je voudrais savoir, comment puis-je passer certains paramètres sur la carte de prédicats?

I. e. Je voudrais obtenir un prédicat à partir d'une carte par sa chaîne abréviation et insérer un paramètre dans la prise à partir d'une carte de prédicat.

pl.stream()
    .filter(search.getCriteria("allPilots",45, 56))
    .forEach(p -> {
        p.printl(p.getPrintStyle("westernNameAgePhone"));
    });

Ici est la lien de j'ai googlé cette carte-prédicat approche.

Ce que vous voulez faire serait de ne pas compiler, et vous n'avez pas d'expliquer ce que c'est censé faire.
J'ai juste donné un exemple. Bien sûr, il l'habitude de compiler. Voici ce que je voudrais faire: je voudrais obtenir un prédicat à partir d'une carte par sa chaîne abréviation et insérer un paramètre dans la prise à partir d'une carte de prédicat.
Que serait le paramètre être utilisé? Quel est l'objectif de 45 dans votre exemple?
45 avec le 56 sont le filtrage des paramètres pour donner un prédicat allPilots c'est à dire ce prédicat doit retourner false si le pilote de l'âge n'est pas dans la tranche d'âge (45, 65).
OK. Mais que serait ce paramètre signifie que, si vous avez passé "allDrivers" ou "allDraftees" au lieu de "allPilots". Vous semblez vouloir contradictor choses en même temps: magasin de prédicats dans une carte pour être en mesure à un avec une clé de chaîne sans prendre soin de comment il est mis en œuvre, et aussi être en mesure de passer un paramètre à personnaliser le prédicat, mais ils ont tous à faire les choses différemment.

OriginalL'auteur mr.M | 2015-08-23

9

Il semble que ce que vous voulez, c'est de ne pas stocker un prédicat dans une Carte. Ce que vous voulez est d'être capable de stocker quelque chose dans une carte qui est capable de créer un Predicate<Person> à partir d'un int paramètre. Donc, ce que vous voulez, c'est quelque chose comme ceci:
```
Map<String, IntFunction<Predicate<Person>>> searchMap = new HashMap<>();
```
Vous remplir de cette façon:
```
searchMap.put("allPilots", maxAge -> 
    (p -> p.getAge() >= 23
     && p.getAge() <= maxAge));
```
Et vous pouvez l'utiliser comme ceci:
```
Predicate<Person> allPilotsAgedLessThan45 = 
    searchMap.get("allPilots").apply(45);
```
Bien sûr, il serait plus clair si vous avez créé votre propre interface fonctionnelle:
```
@FunctionalInterface
public MaxAgePersonPredicateFactory {
    Predicate<Person> limitToMaxAge(int maxAge);
}
```
Vous auriez encore à remplir la carte de la même manière, mais il vous faudra alors un peu plus lisible le code lors de son utilisation:
```
Predicate<Person> allPilotsAgedLessThan45 = 
    searchMap.get("allPilots").limitToMaxAge(45);
```
Exactement ce que je cherchais. Merci!!!!
Étant donné que l'OP veut passer dans deux int params, ne devrait-ce pas être un BiFunction<Integer, Integer, Prédicat<Personne>> au lieu d'une IntFunction?
J'ai raté le deuxième paramètre de la question et seulement remarqué l'45. Mais oui, si il a besoin de deux paramètres, la signature de l'usine va devoir changer.

OriginalL'auteur JB Nizet

Ce que je comprends, ce que vous voulez faire est de remplacer certains paramètres dans un Predicate, mais je pense que cela va conduire à la confusion. Si je pose la question pour le prédicat qui détermine si quelqu'un a le droit d'être un pilote, je ne veux pas avoir à vous inquiéter de savoir quelles sont les exigences à l'époque quand je l'appelle.

Générer des prédicats à la volée à l'aide d'un Map serait difficile - je pense que la plus belle façon serait plutôt une Map<String, PredicateFactory>, où la PredicateFactory est une sorte de complexe de classe qui génère des prédicats compte tenu de certains paramètres:

Map<String, PredicateFactory<T>> predicates = new HashMap<>();

public Predicate<T> get(String name, Object... params) {
    return predicates.get(name).apply(params);
}

À mon avis, la meilleure façon de générer des "dynamique" prédicats est avec des méthodes statiques:

public class PredicatesQuestion {

    public static void main(String[] args) {
        List<Person> people = Arrays.asList(new Person(20, Gender.MALE),
                new Person(45, Gender.FEMALE), new Person(50, Gender.MALE),
                new Person(65, Gender.MALE));

        people.stream()
                .filter(personIsBetweenAges(16, 25))
                .forEach(person -> {
                    System.out.println(person.getAge() + ", " + person.getGender());
                });
    }

    private static Predicate<Person> personIsMale() {
        return person -> person.getGender() == Gender.MALE;
    }

    private static Predicate<Person> personIsBetweenAges(int lower, int upper) {
        return personIsAtLeast(lower).and(personIsYoungerThan(upper));
    }

    private static Predicate<Person> personIsAtLeast(int age) {
        return person -> person.getAge() >= age;
    }

    private static Predicate<Person> personIsYoungerThan(int age) {
        return person -> person.getAge() < age;
    }
}

Il est alors trivial de créer des descriptifs des prédicats:

private static Predicate<Person> personIsOfDrivingAge() {
    return personIsAtLeast(17);
}

private static Predicate<Person> couldBePilot() {
    return personIsBetweenAges(23, 65).and(personIsMale());

}

Et le genre de chose que vous essayez d'atteindre au remplacement de certains paramètres reste clair avec un peu de composition:

people.stream()
        .filter(couldBePilot().and(personIsBetweenAges(45, 56)))
        .forEach(person -> {
            System.out.println(person.getAge() + ", " + person.getGender());
        });

OriginalL'auteur Edd

Vous devez vous connecter pour publier un commentaire.