Bonjour,

J'ai une petite question concernant la fonction stream() et filter() / map().

J'ai le code suivant :

List<Integer> nombres = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
      
    List<Integer> troisPremierNombrePairAuCarre = 
      nombres.stream()
             .filter(n -> {
                 System.out.println("filter " + n);
                 return n % 2 == 0;
              })
             .map(n -> {
                 System.out.println("map " + n);
                 return n * n;
              })
             .limit(3)
             .collect(toList());

    System.out.println("");
    troisPremierNombrePairAuCarre.forEach(System.out::println);

Cela me renvoie :

filter 1
filter 2
map 2
filter 3
filter 4
map 4
filter 5
filter 6
map 6
4
16
36

Alors que je pensais que ça devait plutôt me renvoyer cela :

filter 1
filter 2
filter 3
filter 4
filter 5
filter 6
filter 7
filter 8
map 2 // nombres pairs récupérés
map 4
map 6
map 8
4 // on récupère les 3 premiers
16
36

Je ne comprends pourquoi cela fait filter 1, 2 puis map 2, filter 3 , 4 puis map 4, etc.

Du coup, je pense ne pas avoir bien compris l'ordre d'exécution... 

Quelqu'un saurait-il éclairer ma lanterne ?

Par avance merci et bonne journée

-
Edité par Ninicocolalas 15 mars 2024 à 12:56:30

Le flux se fait sur chaque entree, une par une et heureusement sinon il ferait trop d'operations inutiles.

Ce n'est qu'a l'operation terminale (le toList) que les resultats sont regroupe.

En gros, le "pipeline" qui est montré, c'est comme

• Une boucle qui parcourt le tableau
• Dans laquelle il y a un test sur chacun des éléments
• Si il satisfait le test de parité, on l'affiche et on calcule son carré
• Que l'on met dans une liste
• Qui est retournée quand la boucle est finie.

Mais ça permet de voir ça comme si

• A partir de la liste des éléments, on construisait une liste "virtuelle" des éléments qui sont pairs par sélection
• À partir de celle ci on construit la liste de leurs carrés (en appliquant une fonction qui donne le carré)
• Que l'on range

Ce qui est une composition de fonctions appliquées à des streams (= les listes virtuelles, c'est de l'évaluation paresseuse), une abstraction qui simplifie le codage.

-
Edité par michelbillaud 19 mars 2024 à 15:27:05