Introduite dans Java 8, l'API Stream est utilisée pour traiter des collections d'objets. Un flux en Java est une séquence d'objets qui prend en charge diverses méthodes qui peuvent être pipelinées pour produire le résultat souhaité.
Utilisation de Stream en Java
Les utilisations de Stream en Java sont mentionnées ci-dessous :
- L'API Stream est un moyen d'exprimer et de traiter des collections d'objets.
- Permettez-nous d’effectuer des opérations telles que le filtrage, le mappage, la réduction et le tri.
Comment créer un flux Java ?
La création de Java Stream est l'une des étapes les plus élémentaires avant d'envisager les fonctionnalités de Java Stream. Vous trouverez ci-dessous la syntaxe indiquée sur la façon de déclarer Java Stream.
Syntaxe
Stream stream;>
Ici, T est soit une classe, un objet ou un type de données en fonction de la déclaration.
Fonctionnalités du flux Java
Les fonctionnalités du flux Java sont mentionnées ci-dessous :
- Un flux n'est pas une structure de données, il prend plutôt les entrées des collections, des tableaux ou des canaux d'E/S.
- Les flux ne modifient pas la structure des données d'origine, ils fournissent uniquement le résultat selon les méthodes pipeline.
- Chaque opération intermédiaire est exécutée paresseusement et renvoie un flux en conséquence, diverses opérations intermédiaires peuvent donc être pipeline. Les opérations du terminal marquent la fin du flux et renvoient le résultat.
Différentes opérations sur les flux
Il existe deux types d'opérations dans les flux :
- Opérations intermédiaires
- Terminer les opérations
Opérations intermédiaires
Les opérations intermédiaires sont les types d’opérations dans lesquelles plusieurs méthodes sont enchaînées à la suite.
Caractéristiques des opérations intermédiaires
- Les méthodes s’enchaînent.
- Les opérations intermédiaires transforment un flux en un autre flux.
- Il active le concept de filtrage dans lequel une méthode filtre les données et les transmet à une autre méthode après traitement.
Avantage de Java Stream
Il existe certains avantages pour lesquels nous utilisons Stream en Java, comme mentionné ci-dessous :
- Pas de stockage
- Pipeline de fonctions
- Paresse
- Peut être infini
- Peut être parallélisé
- Peut être créé à partir de collections, de tableaux, de lignes de fichiers, de méthodes dans Stream, IntStream, etc.
Opérations intermédiaires importantes
Il y a quelques opérations intermédiaires mentionnées ci-dessous :
1. carte()
La méthode map est utilisée pour renvoyer un flux constitué des résultats de l'application de la fonction donnée aux éléments de ce flux.
List number = Arrays.asList(2,3,4,5); List square = number.stream().map(x->x*x).collect(Collectors.toList());>
2. filtre()
La méthode de filtrage est utilisée pour sélectionner des éléments selon le prédicat passé en argument.
np rembourrage
List names = Arrays.asList('Reflection','Collection','Stream'); List result = names.stream().filter(s->s.startsWith('S')).collect(Collectors.toList());> 3. trié()
La méthode sorted est utilisée pour trier le flux.
List names = Arrays.asList('Reflection','Collection','Stream'); List result = names.stream().sorted().collect(Collectors.toList());> Opérations des terminaux
Les opérations de terminal sont le type d’opérations qui renvoient le résultat. Ces opérations ne sont pas traitées davantage, elles renvoient simplement une valeur de résultat final.
Opérations importantes du terminal
Quelques opérations de terminal sont mentionnées ci-dessous :
1. collecter()
La méthode collect permet de renvoyer le résultat des opérations intermédiaires effectuées sur le flux.
List number = Arrays.asList(2,3,4,5,3); Set square = number.stream().map(x->x*x).collect(Collectors.toSet());>
2. pourChaque()
La méthode forEach est utilisée pour parcourir chaque élément du flux.
List number = Arrays.asList(2,3,4,5); number.stream().map(x->x*x).forEach(y->System.out.println(y));>
3. réduire()
La méthode de réduction est utilisée pour réduire les éléments d’un flux à une seule valeur. La méthode de réduction prend un BinaryOperator comme paramètre.
List number = Arrays.asList(2,3,4,5); int even = number.stream().filter(x->x%2==0).reduce(0,(ans,i)-> ans+i);>
Ici, la variable ans se voit attribuer 0 comme valeur initiale et i y est ajouté.
Note: Les opérations intermédiaires s'exécutent sur la base du concept d'évaluation paresseuse, qui garantit que chaque méthode renvoie une valeur fixe (opération de terminal) avant de passer à la méthode suivante.
Exemple de flux Java
Java
// Java program to demonstrate> // the use of stream in java> import> java.util.*;> import> java.util.stream.*;> class> Demo {> >public> static> void> main(String args[])> >{> >// create a list of integers> >List number = Arrays.asList(>2>,>3>,>4>,>5>);> >// demonstration of map method> >List square> >= number.stream()> >.map(x ->x * x)> >.collect(Collectors.toList());> >// create a list of String> >List names = Arrays.asList(> >'Reflection'>,>'Collection'>,>'Stream'>);> >// demonstration of filter method> >List result> >= names.stream()> >.filter(s ->s.commenceAvec(>'S'>))> >.collect(Collectors.toList());> > >System.out.println(result);> >// demonstration of sorted method> >List show> >= names.stream()> >.sorted()> >.collect(Collectors.toList());> > >System.out.println(show);> >// create a list of integers> >List numbers> >= Arrays.asList(>2>,>3>,>4>,>5>,>2>);> >// collect method returns a set> >Set squareSet> >= numbers.stream()> >.map(x ->x * x)> >.collect(Collectors.toSet());> > >System.out.println(squareSet);> >// demonstration of forEach method> >number.stream()> >.map(x ->x * x)> >.forEach(y ->System.out.println(y));> >// demonstration of reduce method> >int> even> >= number.stream()> >.filter(x ->x %>2> ==>0>)> >.reduce(>0>, (ans, i) ->ans + i);> >System.out.println(even);> >}> }> |
>
>
gzip pour Linux
Sortir
[4, 9, 16, 25] [Stream] [Collection, Reflection, Stream] [16, 4, 9, 25] 4 9 16 25 6>
Points/Observations importants de Java Stream
- Un flux se compose d'une source suivie de zéro ou plusieurs méthodes intermédiaires combinées (pipelined) et d'une méthode terminale pour traiter les objets obtenus à partir de la source selon les méthodes décrites.
- Stream est utilisé pour calculer des éléments selon les méthodes pipeline sans modifier la valeur d'origine de l'objet.