Introduction aux Streams

Entrées/sorties et flux en Java

Alex Liu

Software Development Engineer

Travailler avec les Streams

Streams{{1}} en Java
- Traitent des collections de données de façon fonctionnelle et améliorent les performances sur de gros volumes
- Collections prises en charge :
  - Listes (p. ex. ArrayList, LinkedList)
  - Ensembles (p. ex. HashSet, TreeSet)
  - Dictionnaires (Keys/Values en Streams) (p. ex. HashMap, TreeMap)
  - Tableaux (via Arrays.stream())
Exemple ArrayList nommé names à utiliser pour la suite de la vidéo
```
names: ["Alice", "Bob", "Charlie", "David"]
```

Utiliser les expressions lambda avec Stream

Expressions lambda
- Syntaxe : (parameters) -> { expression }

names.forEach(
    // `name` est un paramètre représentant chaque élément de la liste
    name -> 
        // Expression exécutée pour chaque élément.
        System.out.println(name));

Alice 
Bob 
Charlie 
David

Créer un Stream

Convertir une collection en Stream
- Utilisez .stream() sur une collection
- Prend en charge List, Set et Queue
Importer la classe Stream
```
import java.util.stream.Stream;
```
Convertir la liste d'exemple names en flux et utiliser .foreach() pour accéder à chaque élément.
```
Stream<String> stream = names.stream();
stream.forEach(name -> System.out.println(name));
```

Filtrer des données avec les Streams

Utiliser .filter() pour sélectionner des éléments
- Ne garde que les éléments correspondants

Convertir la liste d'exemple names en flux

Stream<String> stream = names.stream();

Utiliser .filter() pour garder les éléments qui commencent par A, puis .forEach() pour les afficher
```
stream
  .filter(name -> name.startsWith("A"))
  .forEach(name -> System.out.println(name));
```
Résultat du filtrage : Alice

Compter des éléments avec les Streams

Utiliser .count() pour compter les éléments
- Retourne une valeur de type long

Convertir la liste d'exemple names en flux

Stream<String> stream = names.stream();

Utiliser .filter() pour garder les éléments qui commencent par B, puis .count() pour les compter
```
long count = names.stream()
  .filter(name -> name.startsWith("B"))
  .count();
```
Résultat du comptage : 1 (un seul élément Bob commence par B)

Quand utiliser les Streams

Quand utiliser les Streams :
- Gros ensembles de données : réduit la surcharge et améliore la perf.
- Opérations fonctionnelles : plus lisible que des boucles
- Filtrage et transformations : code simplifié
Quand NE PAS utiliser les Streams :
- Pour modifier les collections d'origine
- Pour de simples boucles avec effets de bord

Passons à la pratique !

Entrées/sorties et flux en Java