Stream en JAVA
[Link]
1. Qu'est-ce qu'un Stream ?
Un Stream est une séquence d'éléments qui provient de différentes sources,
comme des collections, des tableaux, ou des fichiers. Les Streams sont conçus
pour traiter des données de manière déclarative, en permettant d'écrire des
opérations sur les données de manière concise et lisible.
Les Streams sont non stockés, ce qui signifie qu'ils ne conservent pas les
données, mais les traitent à la volée. Cela permet une gestion efficace de la
mémoire.
Concepts Clés des Streams :
Séquence d'Éléments : Les Streams représentent une séquence d'éléments qui
peuvent provenir de diverses sources comme des listes, des ensembles ou des
tableaux.
Traitement de Données : Les Streams permettent d'effectuer des transformations,
des filtrages, des tris, et d'autres opérations de manière fluide et lisible.
Pas de Stockage : Les Streams ne conservent pas les éléments en mémoire. Ils
traitent les données à la volée, ce qui permet de gérer efficacement la mémoire,
surtout avec de grandes quantités de données.
2. Création de Streams
Les Streams peuvent être créés à partir de plusieurs sources. Voici quelques méthodes de
création de Streams :
À partir de Collections :
List<String> liste = [Link]("apple", "banana", "orange");
Stream<String> streamFromList = [Link]();
À partir de Tableaux :
String[] array = {"apple", "banana", "orange"};
Stream<String> streamFromArray = [Link](array);
À partir de Valeurs Fixes :
Stream<String> streamOfValues = [Link]("apple", "banana", "orange");
Streams Infini :
1
Stream<Integer> infiniteStream = [Link](0, n -> n + 1); // Génère des entiers à l'infini
3. Types de Streams
Les Streams en Java peuvent être de différents types en fonction des données qu'ils
contiennent. Les plus courants sont :
Stream<T> : Pour traiter des objets.
IntStream, LongStream, DoubleStream : Pour traiter des primitives (int, long,
double). Ces Streams offrent des méthodes spécifiques pour travailler avec des
valeurs numériques, comme sum(), average(), min(), et max().
Exemple avec DoubleStream :
DoubleStream doubleStream = [Link](1.5, 2.5, 3.5);
double total = [Link](); // Calcule la somme des valeurs
4. Opérations Intermédiaires et Terminales
Les opérations sur les Streams se divisent en deux catégories : opérations intermédiaires et
opérations terminales.
Opérations Intermédiaires
Ces opérations retournent un nouveau Stream et ne sont pas exécutées tant qu'une
opération terminale n'est pas appelée. Voici quelques opérations intermédiaires courantes :
filter : Permet de garder seulement les éléments qui satisfont un prédicat.
List<String> fruits = [Link]("apple", "banana", "orange", "kiwi");
Stream<String> filteredFruits = [Link]().filter(fruit -> [Link]("a"));
map : Applique une fonction à chaque élément et retourne un Stream avec les
résultats.
List<String> fruits = [Link]("apple", "banana", "orange");
Stream<Integer> fruitLengths = [Link]().map(String::length);
sorted : Trie les éléments du Stream.
List<String> fruits = [Link]("banana", "apple", "orange");
Stream<String> sortedFruits = [Link]().sorted();
distinct : Supprime les doublons.
List<Integer> numbers = [Link](1, 2, 2, 3, 4, 4);
Stream<Integer> distinctNumbers = [Link]().distinct();
Opérations Terminales
2
Ces opérations déclenchent l'exécution des opérations intermédiaires et retournent un
résultat ou un effet de bord. Voici quelques opérations terminales courantes :
forEach : Applique une action à chaque élément.
[Link]().forEach([Link]::println);
collect : Collecte les résultats dans une collection, comme une liste ou un ensemble.
List<String> collectedFruits = [Link]()
.filter(fruit -> [Link]() > 5)
.collect([Link]());
count : Compte le nombre d'éléments.
long count = [Link]().count();
reduce : Réduit les éléments en une seule valeur.
Optional<String> concatenated = [Link]().reduce((s1, s2) -> s1 + s2);
Exemple : Analyser une liste de produits
import [Link];
import [Link];
import [Link];
class Produit {
String nom;
double prix;
Produit(String nom, double prix) {
[Link] = nom;
[Link] = prix;
}
public String getNom() {
return nom;
}
3
public double getPrix() {
return prix;
}
}
public class AnalyseProduits {
public static void main(String[] args) {
List<Produit> produits = [Link](
new Produit("Pomme", 0.5),
new Produit("Banane", 0.2),
new Produit("Orange", 0.3),
new Produit("Kiwi", 0.8)
);
// Calculer le total des prix
double totalPrix = [Link]()
.mapToDouble(Produit::getPrix)
.sum();
[Link]("Total des prix : " + totalPrix + " CFA");
// Trouver le produit le plus cher
Produit produitPlusCher = [Link]()
.max((p1, p2) -> [Link]([Link](), [Link]()))
.orElse(null);
[Link]("Produit le plus cher : " + (produitPlusCher != null ?
[Link]() : "Aucun produit"));
4
// Obtenir une liste des noms de produits triés par prix
List<String> nomsProduitsTries = [Link]()
.sorted((p1, p2) -> [Link]([Link](), [Link]()))
.map(Produit::getNom)
.collect([Link]());
[Link]("Produits triés par prix : " + nomsProduitsTries);
}
}
8. Exercices Pratiques
Voici quelques exercices supplémentaires pour pratiquer l'utilisation des Streams.
Exercice 1 : Filtrer et afficher les nombres impairs d'une liste.
import [Link];
import [Link];
public class Exercice1 {
public static void main(String[] args) {
List<Integer> nombres = [Link](1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// À compléter
}
}
Exercice 2 : Trouver la somme des carrés des nombres pairs d'une liste.
import [Link];
import [Link];
public class Exercice2 {
public static void main(String[] args) {
List<Integer> nombres = [Link](1, 2, 3, 4, 5, 6);
5
// À compléter
}
}
Exercice 3 : Compter le nombre de mots qui commencent par une lettre spécifique dans
une liste.
import [Link];
import [Link];
public class Exercice3 {
public static void main(String[] args) {
List<String> mots = [Link]("chat", "chien", "éléphant", "souris", "rat");
// À compléter
}
}
9. Solutions aux Exercices
Voici les solutions pour chaque exercice.
Solution de l'Exercice 1
[Link]()
.filter(n -> n % 2 != 0) // Filtre les nombres impairs
.forEach([Link]::println); // Affiche chaque nombre
Solution de l'Exercice 2
double sommeDesCarres = [Link]()
.filter(n -> n % 2 == 0) // Filtre les nombres pairs
.mapToDouble(n -> n * n) // Calcule le carré de chaque nombre
.sum(); // Calcule la somme
[Link]("Somme des carrés des nombres pairs : " + sommeDesCarres);
6
Solution de l'Exercice 3
char lettre = 'c'; // Lettre à vérifier
long count = [Link]()
.filter(mot -> [Link]([Link](lettre))) // Vérifie si le mot commence
par la lettre
.count(); // Compte les mots
[Link]("Nombre de mots qui commencent par " + lettre + " : " + count);
