Java8 de Flux de données - utiliser le filtre de recueillir foreach en ligne

Est pas possible d'utiliser le filtre(),collect() et foreach() dans un état unique au lieu de plusieurs états?

J'ai une carte et de la nécessité de filtre basé sur une condition et définir certaines valeurs sur le contenu et le retour de la carte. Mon actuel ressemble à ci-dessous, mais je veux que tous les 3 dans la même instruction.

Carte inputMap (contient toutes les infos)

Map<String, Person> returnMap; 
            returnMap = map.entrySet().stream()
            .filter(p ->  p.getValue().getCourse() == 123)
            .collect(Collectors.toMap(p -> p.getKey(), p -> p.getValue()));

            returnMap.entrySet().stream().forEach((entry) -> {
                Person person= entry.getValue();                
                person.setAction("update");
                person.setLastUpdatedTime(new Date());
            });

cela peut-il être converti,

  Map<String, Person> returnMap; 
                returnMap = map.entrySet().stream()
                .filter(p ->  p.getValue().getCourse() == 123)
                .collect(Collectors.toMap(p -> p.getKey(), p -> p.getValue())) 
 .forEach((entry) -> {
                    Person person= entry.getValue();                
                    person.setAction("update");
                    person.setLastUpdatedTime(new Date());
                });

(ce code ne fonctionne pas)

InformationsquelleAutor skumar | 2016-06-08
  1. 16

    Le problème est que forEach ne renvoie pas à un objet de sorte que vous avez à gérer différents. Vous pouvez le faire de cette façon: 

    Map<String, Person> returnMap = new HashMap<>(); 
map.entrySet().stream()
              .filter(p ->  p.getValue().getCourse() == 123)
              .forEach((entry) -> {
                    Person person = entry.getValue();                
                    person.setAction("update");
                    person.setLastUpdatedTime(new Date());
                    returnMap.put(entry.getKey(), person);
                });
    • comme cette approche
    • C'est une solution, non sans ironie, car elle est composée de deux états. Et bien sûr, il n'est pas compatible avec les flux parallèles.
    InformationsquelleAutor Kevin Wallis
  2. 4

    Il n'y a pas de sens en insistant sur le fait avec une seule opération. Indépendamment de la façon dont vous l'écrivez, ces sont deux opérations.

    Mais une chose que vous devriez prendre en compte, est, qu'il y a plus de moyens que entrySet().stream() pour traiter tous les éléments:

    Map<String, Person> returnMap = map.entrySet().stream()
    .filter(p ->  p.getValue().getCourse() == 123)
    .collect(Collectors.toMap(p -> p.getKey(), p -> p.getValue()));

returnMap.values().forEach(person -> {          
    person.setAction("update");
    person.setLastUpdatedTime(new Date());
});

    Si vous insistez toujours sur le fait apparaître comme une seule opération, vous pouvez le faire de cette façon:

    Map<String, Person> returnMap = map.entrySet().stream()
    .filter(p ->  p.getValue().getCourse() == 123)
    .collect(Collectors.collectingAndThen(
        Collectors.toMap(p -> p.getKey(), p -> p.getValue()),
        tmp -> {
            tmp.values().forEach(person -> {          
                person.setAction("update");
                person.setLastUpdatedTime(new Date());
            });
            return tmp;
        })
    );

    C'est la syntaxe d'une instruction unique, encore, c'est exactement la même que l'ancienne variante.

    InformationsquelleAutor Holger
  3. 1

    Je ne comprends pas le besoin de le séparer en deux étapes, comme cela a été suggéré. Il semble que la transformation peut être effectuée avant l'exploitation du terminal, comme ceci:

    returnMap = map.entrySet().stream()
                .filter(p -> p.getValue().getCourse() == 123)
                .map(e -> {
                    Person p = e.getValue();
                    p.setAction("update");
                    p.setLastUpdatedTime(new Date());
                    return e;
                })
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

    Si vous êtes sensibles à propos des effets secondaires de la Map.Entry diffusées en continu, vous pouvez renvoyer une nouvelle AbstractMap.SimpleEntry avec la mise à jour Person comme sa valeur, mais aucune solution à ce jour est libre d'effets secondaires, puisque les valeurs à l'origine de la Carte sont en cours de modification. Peu importe, ici, c'est la variation:

    returnMap = map.entrySet().stream()
                .filter(p -> p.getValue().getCourse() == 123)
                .map(e -> {
                    Person p = e.getValue();
                    p.setAction("update");
                    p.setLastUpdatedTime(new Date());
                    return new AbstractMap.SimpleEntry<>(e.getKey(), p);
                })
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
    • La principale préoccupation est de l'interférence. Le côté effet de la modification de la Person cas, c'est inévitable, car c'est l'opération souhaitée. Des problèmes peuvent survenir, lorsque les méthodes de définition des instances différentes de la personne en quelque sorte interagir ou lorsqu'une instance particulière se produit plusieurs fois. Sinon, vous pourriez même utiliser peek ici, ce qui serait plus concis que map. De conversion de l'entrée dans une autre entrée ne change pas si la modification du Person instance a des interférences ou pas, donc c'est inutile.
    InformationsquelleAutor Hank D