Transformation des données avec les Streams

Entrées/sorties et flux en Java

Alex Liu

Software Development Engineer

Transformation des données avec les streams

Transformation des données avec les streams
- Convertir des formats, agréger et filtrer des informations
- Stocker les résultats dans un nouveau type de collection (p. ex., de List à Set)
- Collections prises en charge :
  - Listes (p. ex. ArrayList, LinkedList)
  - Ensembles (p. ex. HashSet, TreeSet)
  - Maps (Keys/Values en Streams) (p. ex. HashMap, TreeMap)
  - Tableaux (via Arrays.stream())
Exemple ArrayList nommé names à utiliser pour le reste de la vidéo
```
names: ["Alice", "Bob", "Charlie", "David"]
```

Utiliser Stream pour transformer des éléments

Préparation : importer les classes requises Set, Collectors et Stream

import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;


// Convert the `ArrayList` we created earlier `names` to a `Stream`
Stream<String> namesStream = names.stream();

Données actuelles : [Alice, Bob, Charlie, David]

Utiliser Stream pour transformer des éléments (suite)

// Use `.map()` to convert each element to upper case
Stream<String> upperCaseNameStream = namesStream.map(
        name -> name.toUpperCase())

Données actuelles : [ALICE, BOB, CHARLIE, DAVID]

// use `.collect()` and `Collectors.toSet()` to store the transformed stream data
upperCaseNameStream.collect(Collectors.toSet())

Données finales :
```
{CHARLIE, ALICE, BOB, DAVID}
```

Utiliser Stream pour l'agrégation

La méthode .reduce()
- Agréger les éléments en un seul résultat
- Utile pour addition, concaténation ou min/max
Utiliser .reduce() nécessite deux entrées
- Valeur initiale : point de départ de l'accumulation, p. ex. 0
- Opérateur binaire : fonction qui prend deux arguments
  - (x, y) -> x + y signifie :
    - x représente le total accumulé
    - y représente l'élément en cours de traitement
    - On ajoute y à x jusqu'à ce que tous les éléments soient traités

Utiliser Stream pour l'agrégation : exemple

Convertir l'ArrayList names en objet Stream.

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

Utiliser .map() pour convertir chaque nom en sa longueur, puis .reduce() pour les additionner
```
stream
  .map(name -> name.length())
  .reduce(0, (sum, length) -> sum + length);
```
Résultat : 20

Passons à la pratique !

Entrées/sorties et flux en Java