Qu'est-ce que l'API de flux ?
L'API Stream est une nouvelle fonctionnalité introduite dans Java 8 qui fournit un moyen fonctionnel de diffuser les données de collecte. L'API Stream nous permet de traiter les données de collecte de manière plus concise et lisible, et en même temps, elle peut tirer pleinement parti des capacités de traitement parallèle des processeurs multicœurs pour améliorer l'efficacité de l'exécution du programme.
Dans l'API Stream, nous pouvons traiter les données de collecte via une série d'opérations, qui peuvent être divisées en opérations intermédiaires et opérations de terminaison. L'opération intermédiaire consiste à traiter et transformer les données du flux, mais ne produira pas le résultat final ; l'opération de terminaison est l'opération qui produit le résultat final, qui déclenchera le traitement du flux et renverra le résultat.
L'API Stream comprend principalement les parties suivantes :
- Création de flux : créez des flux via des collections, des tableaux, des fichiers, etc.
- Flux d'opération : effectuez des opérations telles que le filtrage, le mappage, le tri et la déduplication sur le flux.
- Terminez les flux : convertissez les flux en collections, tableaux, statistiques récapitulatives, vérifications de correspondance, etc.
Ci-dessous, nous présenterons en détail comment utiliser l'API Stream en Java.
Comment utiliser l'API Stream en Java ?
création de flux
En Java, nous pouvons créer des flux de plusieurs manières. Voici quelques méthodes courantes pour créer des flux :
Créer un flux à partir d'une collection
List<String> list = Arrays.asList("a", "b", "c", "d");
Stream<String> stream = list.stream();
Créer un flux à partir d'un tableau
int[] array = {
1, 2, 3, 4, 5};
IntStream stream = Arrays.stream(array);
Créer un flux à partir d'un fichier
Path path = Paths.get("file.txt");
Stream<String> stream = Files.lines(path);
Créer un flux à partir d'une fonction
Stream.generate(() -> "hello")
.limit(5)
.forEach(System.out::println);
Dans le code ci-dessus, nous utilisons la méthode Stream.generate() pour créer un flux infini, qui générera en continu la chaîne "hello", puis utiliserons la méthode limit() pour intercepter le flux, et enfin sortir les 5 premiers éléments .
flux de fonctionnement
Après avoir créé le flux, nous pouvons effectuer une série d'opérations sur le flux pour réaliser le traitement et la transformation des données. Voici quelques opérations de flux couramment utilisées :
méthode filtre()
La méthode filter() permet de filtrer les données du flux, et de ne conserver que les données qualifiées, afin d'obtenir un nouveau flux.
List<String> list = Arrays.asList("a", "b", "c", "d");
Stream<String> stream = list.stream().filter(s -> s.startsWith("a"));
Dans le code ci-dessus, nous utilisons la méthode filter() pour filtrer les chaînes commençant par "a" et obtenir un nouveau flux.
méthode map()
La méthode map() peut transformer les données du flux pour obtenir un nouveau flux.
List<String> list = Arrays.asList("a", "b", "c", "d");
Stream<String> stream = list.stream().map(String::toUpperCase);
Dans le code ci-dessus, nous utilisons la méthode map() pour convertir la chaîne en majuscule et obtenir un nouveau flux.
méthode triée()
La méthode sorted() peut trier les données dans le flux pour obtenir un nouveau flux.
List<String> list = Arrays.asList("b", "a", "d", "c");
Stream<String> stream = list.stream().sorted();
Dans le code ci-dessus, nous utilisons la méthode sorted() pour trier les chaînes et obtenir un nouveau flux.
méthode distinct()
La méthode distinct() peut dédupliquer les données du flux pour obtenir un nouveau flux.
List<String> list = Arrays.asList("a", "b", "a", "c");
Stream<String> stream = list.stream().distinct();
Dans le code ci-dessus, nous utilisons la méthode distinct() pour dédupliquer la chaîne et obtenir un nouveau flux.
méthode peek()
La méthode peek() peut opérer sur les données du flux sans modifier les données du flux, mais elle peut générer des informations pendant l'opération.
List<String> list = Arrays.asList("a", "b", "c", "d");
Stream<String> stream = list.stream().peek(System.out::println);
Dans le code ci-dessus, nous utilisons la méthode peek() pour opérer sur la chaîne et afficher la valeur de la chaîne, mais les données du flux ne seront pas modifiées.
mettre fin au flux
Après avoir opéré sur le flux, nous pouvons transformer le flux en un résultat final en mettant fin à l'opération. Voici quelques opérations de terminaison couramment utilisées :
méthode collect()
La méthode collect () peut collecter les éléments du flux dans une collection, telle que List, Set, Map, etc.
List<String> list = Arrays.asList("a", "b", "c", "d");
List<String> result = list.stream().collect(Collectors.toList());
Dans le code ci-dessus, nous utilisons la méthode collect () pour collecter les éléments du flux dans une liste.
méthode reduce()
La méthode reduce() peut effectuer des opérations telles que l'accumulation et la sommation sur les éléments du flux pour obtenir un résultat final.
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int sum = list.stream().reduce(0, Integer::sum);
Dans le code ci-dessus, nous utilisons la méthode reduce() pour additionner les nombres entiers et obtenir le résultat final.
méthode count()
La méthode count() peut compter le nombre d'éléments dans le flux.
List<String> list = Arrays.asList("a", "b", "c", "d");
long count = list.stream().count();
Dans le code ci-dessus, nous utilisons la méthode count() pour compter le nombre d'éléments dans le flux.
méthode forEach()
La méthode forEach() peut fonctionner sur chaque élément du flux, comme la sortie vers la console, etc.
List<String> list = Arrays.asList("a", "b", "c", "d");
list.stream().forEach(System.out::println);
Dans le code ci-dessus, nous sortons chaque élément du flux à l'aide de la méthode forEach().
Exemple de code complet
Vous trouverez ci-dessous un exemple de code complet qui montre comment utiliser l'API Stream pour opérer sur les données d'une collection.
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamDemo {
public static void main(String[] args) {
List<String> list = Arrays.asList("hello", "world", "java", "stream", "api");
// 过滤出长度大于 4 的字符串，并将其转换成大写形式
List<String> result = list.stream()
.filter(s -> s.length() > 4)
.map(String::toUpperCase)
.collect(Collectors.toList());
System.out.println(result);
// 统计字符串的个数
long count = list.stream().count();
System.out.println(count);
// 对字符串进行排序，并输出到控制台
list.stream().sorted().forEach(System.out::println);
// 对字符串进行去重，并输出到控制台
list.stream().distinct().forEach(System.out::println);
// 对字符串进行操作，并输出到控制台
list.stream().peek(System.out::println).collect(Collectors.toList());
}
}
Le code ci-dessus montre comment utiliser l'API Stream pour opérer sur les données de la collection et envoyer le résultat à la console.
Résumer
L'API Stream est une nouvelle fonctionnalité introduite dans Java 8 qui fournit un moyen fonctionnel de diffuser les données de collecte. L'API Stream nous permet de traiter les données de collecte de manière plus concise et lisible, et en même temps, elle peut tirer pleinement parti des capacités de traitement parallèle des processeurs multicœurs pour améliorer l'efficacité de l'exécution du programme. Lors de l'utilisation de l'API Stream, nous pouvons traiter les données de collecte via une série d'opérations, qui peuvent être divisées en opérations intermédiaires et opérations de terminaison. L'opération intermédiaire consiste à traiter et transformer les données du flux, mais ne produira pas le résultat final ; l'opération de terminaison est l'opération qui produit le résultat final, qui déclenchera le traitement du flux et renverra le résultat. En utilisant l'API Stream, nous pouvons traiter et convertir les données de collecte plus facilement et améliorer la lisibilité et la maintenabilité du programme.