Simplifier le code avec efficacité / Blogs / Perficient

Présentation des flux Java

Java a introduit les flux dans la version 8 pour simplifier et optimiser l’écriture de code. Un flux est une séquence d’objets prenant en charge diverses méthodes pour obtenir un résultat souhaité. L’utilisation de flux peut réduire un long ensemble de codes à quelques lignes seulement.

Les flux permettent d’effectuer des opérations telles que le filtrage, le mappage, la réduction et le tri. Ces opérations réduisent considérablement la complexité du code.

Dans ce blog, nous passerons en revue la présentation, les fonctionnalités et les opérations de Java Streams.

Opérateur Lambda

L’opérateur lambda « -> », introduit dans Java 8, est une fonctionnalité qui facilite la mise en œuvre d’interfaces fonctionnelles de manière concise et expressive.

En cela, nous divisons la valeur en deux parties, la partie gauche spécifie le paramètre requis par l’expression tandis que la partie droite spécifie les actions/conditions.

Syntaxe : « (paramètres) -> expression »

Caractéristiques des flux Java

Les fonctionnalités du flux Java sont mentionnées ci-dessous :

• Accepte les entrées des collections, des tableaux ou des canaux d’E/S, mais ne sont pas des structures de données elles-mêmes.
• Préservez la structure des données d’origine et fournissez des résultats via des méthodes pipeline.
• Exécutez paresseusement des opérations intermédiaires, permettant le pipeline, les opérations de terminal concluant le flux et donnant le résultat.

Différentes opérations sur les flux

Il existe deux types d’opérations dans les flux :

1. Opérations intermédiaires : Dans les flux Java, ces opérations transforment ou filtrent les éléments paresseusement, générant ainsi un nouveau flux.
2. Terminer les opérations : Concluant des actions sur les flux en Java, ces opérations donnent un résultat ou déclenchent un effet secondaire, signifiant la fin du traitement du flux.

Les opérations intermédiaires et terminales sont interdépendantes et les considérer isolément ne donne pas de résultats significatifs. Par conséquent, pour qu’une opération terminée fonctionne avec succès, l’opération intermédiaire doit renvoyer true.

Le fonctionnement de n’importe quel Stream peut être expliqué selon les étapes suivantes :

• Création de flux.
• Réaliser une opération intermédiaire sur le flux initial pour le transformer en un autre flux.
• Effectuer des opérations de terminal sur le flux final pour obtenir le résultat.

Comprendre la syntaxe des flux :

Saisir:

{ArrayList<String> name = new  ArrayList<String>();

             name.add("abhijeet");

             name.add("Abhishek");

             name.add("Avinaash");

             name.add("shivaansh");

             name.add("Ram");
            

             //To Convert into Stream compatible format we give .stream()
            

             Long c = name.stream().filter(s->s.startsWith("A")).count();

             System.out.println(c);

Sortir:

2

Explication:

Le tableau est rendu compatible avec le flux en utilisant « .streams() »

L’opération intermédiaire pourrait être définie par l’expression « .filter(s->s.startsWith(« A »)) »

L’opération de fin pourrait être définie par « .count(); »

À partir de là, nous avons vu qu’un flux est un tableau qui est une version filtrée et spécifiée du tableau précédent.

Quelques-unes des opérations intermédiaires peuvent être vues comme suit :

1. Filter() : Cette méthode filtre le flux avec une exigence de valeur plus précise.
2. Map() : Cette méthode nous aide à renvoyer un flux composé des résultats de l’application de la fonction donnée aux éléments du flux.
3. Sorted() : Cette méthode est utilisée pour trier le flux.

Quelques-unes des opérations de terminaison peuvent être vues comme suit :

1. forEach() : Cette méthode est utilisée pour parcourir chaque élément du flux.

2. count() : Cette méthode nous donne l’opération intermédiaire effectuée.

3. Collect() : Cette méthode renvoie le résultat des opérations intermédiaires effectuées.

Conclusion

En un mot, Java Streams, introduit dans la version 8 de Java, change la donne en termes de simplicité et d’optimisation du code. Leur capacité à transformer du code complexe en quelques lignes concises améliore l’efficacité et réduit les efforts manuels. Avec des fonctionnalités telles que la gestion non invasive de la structure des données et l’exécution paresseuse des opérations, les flux sont un outil polyvalent pour les développeurs.

L’exemple illustre comment une simple ArrayList peut être transformée sans effort. Les opérations intermédiaires (Filter(), Map(), Sorted()) et les opérations de terminal (forEach(), count(), collect()) fournissent une boîte à outils puissante pour un codage rationalisé. La maîtrise de Java Streams n’est pas seulement une compétence ; il s’agit d’un changement de paradigme dans les pratiques de codage, promettant un avenir meilleur pour l’optimisation du code. Bon codage ! 🚀

Vous pouvez en savoir plus ici : https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html