Tutoriel Java 8 Streams avec des exemples de code

Dans cet article de blog, nous allons discuter des fonctionnalités de Java 8 Streams et fournir de nombreux exemples de code différents.

Les flux Java apportent la programmation fonctionnelle à java et ils sont pris en charge à partir de java 8, donc si vous avez une ancienne version de java, vous devez passer à java 8 pour utiliser Java Streams.



Pourquoi utiliser Java Streams?

Certains des avantages des flux:


  • Les flux feront de vous un programmeur Java plus efficace (vous verrez qu'avec très peu de lignes de code, vous pouvez en fait réaliser beaucoup en utilisant des flux).
  • Ils font un usage intensif des expressions lambda qui sont en quelque sorte des fonctions jetables.
  • ParallelStreams permet très facilement des opérations multithreads pour de grands ensembles de données.


Pipeline Streams

Dans la plupart des cas, un pipeline de flux se compose d'un

  • la source (d'où sortent vos données)
  • suivi de zéro ou plus opérations intermédiaires
  • et une fonctionnement du terminal

Java Streams - Filtrer, mapper, réduire


La source va diffuser un flux d'éléments.

Ce flux d'éléments peut être filtré, trié, ou il peut être mappé ou différentes autres séries d'opérations appliquées à chaque élément.

À la fin, il peut être collecté ou réduit ou une autre opération de terminal, mais une seule opération de terminal est effectuée.

Source du flux

Source du flux peut provenir de collections, de listes, d'ensembles, de tableaux d'int, de longs, de doubles, de chaînes, etc.


Opérations de flux

Opérations de flux sont soit intermédiaires, soit terminaux:

  • Opérations intermédiaires comme le filtre, la carte ou le tri renvoient un flux afin que nous puissions enchaîner plusieurs opérations intermédiaires.
  • Opérations du terminal reçoivent un flux et ils peuvent soit retourner void, soit renvoyer un résultat non flux tel qu'une réduction, par ex. réduire les éléments à une liste.

Opérations intermédiaires

  • Aucune ou plusieurs opérations intermédiaires sont autorisées.
  • L'ordre compte; pour les grands ensembles de données: filtrer d'abord puis trier ou mapper.
  • Pour les très grands ensembles de données, utilisez ParallelStream pour activer plusieurs threads.

Certaines des opérations intermédiaires comprennent:

  • anyMatch ()
  • distinct()
  • filtre()
  • findFirst ()
  • flatmap ()
  • carte()
  • sauter()
  • trié ()

Opérations du terminal

Une seule opération de terminal est autorisée.

  • forEach applique la même fonction à chaque élément, par exemple print chaque élément.
  • collect enregistre tous les éléments dans une collection ou une liste ou un tableau.
  • toutes les autres options réduisent le flux à un seul élément récapitulatif.

Quelques exemples de fonctions de réduction sont:


  • compter()
  • max ()
  • min ()
  • réduire()


Exemples de code Java Streams

Voyons maintenant les concepts ci-dessus dans des exemples de code.

Flux d'entiers

Le premier exemple est juste un flux d'entiers. Nous allons créer un flux d'entiers en utilisant IntStream class et sa fonction range qui nous donne une plage d'entiers.

Le forEach est notre opération de terminal. Pour chaque élément, nous allons simplement l'imprimer.

import java.io.IOException; import java.util.stream.IntStream; public class JavaStreams {
public static void main(String[] args) throws IOException {
IntStream

.range(1, 10)

.forEach(System.out::print);
System.out.println();
} }

Production:


123456789

Flux d'entiers avec saut

Le deuxième exemple utilise un flux d'entiers mais nous avons ajouté un skip() ici, donc dans ce cas, nous allons ignorer les 5 premiers éléments de notre flux.

Cela n'imprimera que les éléments 6 à 9. Nous utilisons également une simple expression lambda pour imprimer l'élément

import java.io.IOException; import java.util.stream.IntStream; public class JavaStreams {
public static void main(String[] args) throws IOException {
IntStream

.range(1, 10)

.skip(5)

.forEach(x -> System.out.println(x));
System.out.println();
} }

Production:

6 7 8 9

Flux d'entiers avec somme

Le troisième exemple, nous utilisons à nouveau le IntStream Cependant, pour créer notre flux d'objets, nous mettons cela à l'intérieur d'un println() instruction comme paramètre de la ligne d'impression.


Ce que nous allons imprimer, ce n’est que la somme de 1 à 5, en d’autres termes, 1 2 3 & 4, il n’imprimera que la somme de ces nombres:

import java.io.IOException; import java.util.stream.IntStream; public class JavaStreams {
public static void main(String[] args) throws IOException {
System.out.println(
IntStream

.range(1, 5)

.sum());
System.out.println();
} }

Production:

10

Flux de

L'exemple suivant utilise le Stream.of , ce qui est vraiment pratique car vous pouvez diffuser des entiers, des valeurs en virgule flottante ou des chaînes ou même des objets.

Dans cet exemple, nous allons simplement faire un tri alphabétique simple, puis nous allons trouver le premier élément en utilisant findFirst() une fonction. Ensuite, nous imprimons simplement le premier élément de la liste.

import java.io.IOException; import java.util.stream.Stream; public class JavaStreams {
public static void main(String[] args) throws IOException {
Stream.of('Ava', 'Aneri', 'Alberto')

.sorted()

.findFirst()

.ifPresent(System.out::println);
} }

Production

Alberto

Diffuser depuis Array, trier, filtrer et imprimer

Dans notre exemple suivant, nous allons diffuser à partir d'un tableau. Ensuite, nous allons trier, filtrer puis imprimer.

Ici, nous allons filtrer uniquement les éléments commençant par s.

Nous utilisons une expression lambda qui prend X qui est chaque nom, puis il vérifie lesquels commencent par la lettre s et il les transmettra.

Ensuite, nous allons les trier, puis pour chaque élément qui passe ce tri, nous allons l’imprimer.

import java.io.IOException; import java.util.Arrays; public class JavaStreams {
public static void main(String[] args) throws IOException {
String[] names = {'Al', 'Ankit', 'Kushal', 'Brent', 'Sarika', 'amanda', 'Hans', 'Shivika', 'Sarah'};
Arrays.stream(names)


.filter(x -> x.startsWith('S'))


.sorted()


.forEach(System.out::println);
} }

Production:

Sarah Sarika Shivika

Moyenne du tableau d'entiers

Voyons maintenant comment nous pouvons prendre la moyenne des carrés d'un tableau int.

Ici, nous utilisons le Arrays.stream() pour diffuser les entiers, puis nous allons utiliser map() pour mapper chaque élément, chaque entier sur son carré.

import java.util.Arrays; public class JavaStreams {
public static void main(String[] args) {
Arrays.stream(new int[] {2, 4, 6, 8, 10})


.map(x -> x * x)


.average()


.ifPresent(System.out::println);
} }

Production:

44.0

Notez qu'il imprime un double au lieu d'un entier.

Diffuser à partir de la liste, filtrer et imprimer

Dans cet exemple, nous allons diffuser à partir d'une liste, filtrer ces éléments, puis imprimer.

Notez que dans le map() fonction, nous allons convertir tous les noms en minuscules.

import java.util.Arrays; import java.util.List; public class JavaStreams {
public static void main(String[] args) {
List people = Arrays.asList('Al', 'Ankit', 'Brent', 'Sarika', 'amanda', 'Hans', 'Shivika', 'Sarah');
people


.stream()


.map(String::toLowerCase)


.filter(x -> x.startsWith('a'))


.forEach(System.out::println);
} }

Production:

al ankit amanda

Nous pouvons voir que nous avons trois noms qui commencent par a et ils sont tous en minuscules.

Diffuser des lignes à partir d'un fichier texte, trier, filtrer et imprimer

Dans notre exemple suivant, nous allons diffuser des lignes à partir d'un fichier texte. Nous allons trier, filtrer et imprimer.

Supposons que nous ayons un fichier appelé bands.txt avec le contenu indiqué ci-dessous:

Rolling Stones Lady Gaga Jackson Browne Maroon 5 Arijit Singh Elton John John Mayer CCR Eagles Pink Aerosmith Adele Taylor Swift

Nous allons utiliser Files.lines() pour créer notre flux qui va nous donner un flux d'une chaîne pour chaque ligne du fichier.

Une fois que nous aurons notre flux, nous allons les trier et nous allons filtrer les éléments de plus de 13 caractères, puis imprimer les éléments restants.

Enfin, nous devons fermer le fichier donc nous faisons bands.close.

import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; import java.util.stream.Stream; public class JavaStreams {
public static void main(String[] args) throws IOException {
Stream bands = Files.lines(Paths.get('bands.txt'));
bands


.sorted()


.filter(x -> x.length() > 13)


.forEach(System.out::println);
bands.close();
} }

Production:

Jackson Browne Rolling Stones

Nous obtenons deux groupes de plus de 13 personnages.

Diffuser des lignes à partir d'un fichier texte et les enregistrer dans la liste

Pour cet exemple, nous utiliserons le même fichier texte que ci-dessus.

Nous voulons filtrer les éléments contenant les lettres jit, en utilisant x.contains() qui est juste une fonction de chaîne.

Utilisation de .collect() on ajoute tous ceux avec des lettres jit à une liste.

Une fois que nous avons la liste de sortie, nous pouvons alors utiliser le forEach opérateur pour imprimer les articles.

import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; import java.util.List; import java.util.stream.Collectors; public class JavaStreams {
public static void main(String[] args) throws IOException {
List bands2 = Files.lines(Paths.get('bands.txt'))


.filter(x -> x.contains('jit'))


.collect(Collectors.toList());
bands2.forEach(x -> System.out.println(x));
} }

Production:

Arijit Singh

Diffuser des lignes à partir du fichier CSV et compter

Dans cet exemple, nous diffusons des lignes à partir d'un fichier CSV et nous allons compter les bonnes lignes.

Supposons que nous ayons un fichier appelé data.txt avec le contenu suivant:

A,12,3.7 B,17,2.8 C,14,1.9 D,23,2.7 E F,18,3.4

Ici, la ligne E n'a pas de données, nous voulons donc exclure celle-ci de notre flux.

Dans le code suivant, nous allons lire dans chaque ligne, puis nous devons diviser entre les virgules dans un tableau afin que chaque ligne devienne un tableau d'éléments.

Ensuite, nous appliquons un filtre pour filtrer les lignes qui ne contiennent pas trois éléments.

import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; import java.util.stream.Stream; public class JavaStreams {
public static void main(String[] args) throws IOException {
Stream rows1 = Files.lines(Paths.get('data.txt'));
int rowCount = (int)rows1


.map(x -> x.split(','))


.filter(x -> x.length == 3)


.count();
System.out.println(rowCount + ' rows.');
rows1.close();
} }

Production:

5 rows

Réduction - somme

Cet exemple vous montre comment utiliser la réduction. Nous allons réduire à une somme. Ici, nous avons un double flux utilisant le Stream.of() une fonction. Nous avons défini trois doubles dans trois arguments différents et nous allons utiliser la fonction de réduction.

import java.util.stream.Stream; public class JavaStreams {
public static void main(String[] args) {
double total = Stream.of(7.3, 1.5, 4.8)


.reduce(0.0, (Double a, Double b) -> a + b);
System.out.println('Total = ' + total);
} }

Production:

13.600000000000001