Pourquoi le « filter() » de Java Stream après « flatMap() » perd-il parfois de la paresse ?

Filtre de flux Java après FlatMap pas complètement paresseux

Les flux Java fournissent un moyen de traiter les pipelines de données via une séquence de transformations. Les opérations intermédiaires sont généralement paresseuses, ce qui signifie qu'elles ne sont exécutées que lorsqu'une opération de terminal est appelée. Cependant, il a été observé que l'application de filter() après flatMap() dans certains scénarios peut conduire à un comportement non paresseux.

Exemple de code

Considérez ce qui suit code :

System.out.println(
        "Result: " +
                Stream.of(1, 2, 3)
                        .filter(i -> {
                            System.out.println(i);
                            return true;
                        })
                        .findFirst()
                        .get()
);
System.out.println("-----------");
System.out.println(
        "Result: " +
                Stream.of(1, 2, 3)
                        .flatMap(i -> Stream.of(i - 1, i, i + 1))
                        .flatMap(i -> Stream.of(i - 1, i, i + 1))
                        .filter(i -> {
                            System.out.println(i);
                            return true;
                        })
                        .findFirst()
                        .get()
);

Sortie

1
Result: 1
-----------
-1
0
1
0
1
2
1
2
3
Result: -1

Explication

Dans le premier cas, l'opération de filtrage est appliquée avant flatMap(), ce qui entraîne une évaluation paresseuse. L'évaluation s'arrête au premier élément correspondant (1).

Dans le deuxième cas, l'opération flatMap() crée un nouveau flux de neuf éléments (-1, 0, 1, 0, 1, 2, 1 , 2, 3). L'opération filter() suivante est appliquée à chacun de ces éléments, ce qui entraîne un comportement non paresseux. Malgré la recherche d'un élément correspondant (-1), l'évaluation continue de traiter tous les éléments du flux.

Correction

Ce problème a été résolu dans JDK-8075939. et corrigé dans Java 10. Il a été rétroporté vers Java 8 dans JDK-8225328.

Le correctif garantit que l'évaluation paresseuse est maintenue en présence des opérations flatMap() et filter(). Cela signifie que l'évaluation se terminera désormais dès qu'un élément correspondant sera trouvé.

Implications

Ce correctif résout les problèmes qui peuvent survenir en raison d'un comportement non paresseux lorsque en utilisant flatMap() et filter(). Il améliore les performances et l'exactitude des pipelines de flux dans les cas où une résiliation anticipée est attendue.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!