Discussion :

[L'aigle de Carthage]

Bonsoir,

j'ai la déclaration suivante:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

    public Map<Medecin,ListPatients> blocmedecin = new HashMap<>();;

et j'ai la méthode RetournerNomPatients qui permet de Retourner les noms des patients dont le numSecuriteSociale = 10, définie comme suit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
return blocmedecin.values()
       .stream().map(e->e.getListP()).
               reduce((l1,l2)->{
                   l1.addAll(l2); 
                   return l1;
                           }).get().stream().
               filter(e->e.getNumSecuriteSociale()==10).
               map(e->e.getNom()).collect(Collectors.toList());

Je me demande c'est quoi l'utilité de la fonction reduce() et la fonction get() dans ce cas?

Merci d'avance

[tchize_]

On va faire dans l'ordre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
blocmedecin.values()   // Collection<ListPatients>
       .stream().map(e->e.getListP()). // Collection<List<Patient>> à priori
               reduce((l1,l2)->{
                   l1.addAll(l2); 
                   return l1;
                           }) //Optional<List<Patient>> contenant tous les patients**
.get()  // List<Patient>
.stream().filter(e->e.getNumSecuriteSociale()==10). // on prend les 10
map(e->e.getNom()) // on prends les noms
.collect(Collectors.toList()); // on en fait une liste

** ce reduce tel que fait est dangereux, il nique la liste patient du médecin en y mettant le contenu des listes patients des autres médecin, tu ne devrais pas toucher cette liste, sauf si getListP() retourne une nouvelle liste à chaque fois. A noter qu'on peux rendre plus lisible et un peu plus propre le code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
return blocmedecin.values().stream()
       .map(ListPatients::getListP())
       .reduce(new ArrayList<Patient>(),(l1,l2)->{l1.addAll(l2); return l1;})
       .stream().filter(e->e.getNumSecuriteSociale()==10)
       .map(Patient::getNom())
       .collect(Collectors.toList());

[adiGuba]

Salut,

** ce reduce tel que fait est dangereux, il nique la liste patient du médecin en y mettant le contenu des listes patients des autres médecin, tu ne devrais pas toucher cette liste, sauf si getListP() retourne une nouvelle liste à chaque fois.

Attention car même là le reduce() n'est pas correct.
Il devrait être stateless et donc ne pas dépendre ou modifier un de ses paramètres.
Dans l'exemple cela "fonctionne" parce qu'on est en séquentielle, mais en parallèle cela pourrait poser des problèmes...

En théorie le reduce() devrait plutôt correspondre à ceci et retourner une valeur distincte de ses paramètres :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
            .reduce(new ArrayList<>(), (l1,l2) -> {
                List<Patient> list = new ArrayList<>(l1.size() + l2.size());
                list.addAll(l1);
                list.addAll(l2);
                return list;
            })

Mais c'est surtout une mauvaise utilisation de reduce() !!!
reduce() sert à obtenir une réduction à un seul élément à partir d'un flux. C'est bien pour faire des sommes ou des trucs du genre, mais pas pour créer une collection (où on utiliserait plutôt collect).

Ici ce qu'on cherche à faire c'est de passer d'un Stream<List<Patient>> à un Stream<Patient> contenant tous les éléments distincts...
Et pour cela il faut utiliser flatMap() :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
        return blocmedecin.values().stream() 
                .map(ListPatients::getListP)
                .flatMap(Collection::stream)
                .filter(e->e.getNumSecuriteSociale()==10)
                .map(Patient::getNom)
                .collect(Collectors.toList());

Et c'est théoriquement plus performant car on n'a pas à créer une collection contenant tous les patients...


a++