Cet article de blog vous montre comment utiliser ** Java 8 ** vers ** Stream API ** pour traiter les données de manière déclarative.

Ce blog est une traduction de la version anglaise. Vous pouvez vérifier l'original depuis ici. Certaines traductions automatiques sont utilisées. Nous vous serions reconnaissants de bien vouloir signaler toute erreur de traduction. *

En Java, les collections et les tableaux sont deux structures de données courantes qui effectuent régulièrement de nombreuses opérations, telles que l'ajout, la suppression, la modification, l'interrogation, l'agrégation, les statistiques et le filtre. Ces opérations existent également dans les bases de données relationnelles. Cependant, avant Java 8, travailler avec des collections et des tableaux n'est pas très pratique.

Ce problème a été considérablement atténué dans Java 8 en introduisant une nouvelle abstraction appelée Stream API, qui vous permet de traiter vos données de manière déclarative. Cet article vous montrera comment utiliser Stream. Veuillez noter que les performances et les principes des flux ne sont pas au cœur de cet article.

Introduction au flux

Les flux fournissent un haut niveau d'abstraction des opérations et expressions de collecte Java en interrogeant les données de la base de données, comme les instructions SQL.

L'API Stream augmente considérablement la productivité des programmeurs Java et leur permet d'écrire du code efficace, propre et concis.

L'ensemble des éléments à traiter est considéré comme un flux transmis dans le pipeline. Ces éléments peuvent être traités par des nœuds dans le pipeline, tels que des filtres, des tris et des agrégats.

Caractéristiques et avantages des flux Java

--Il n'y a pas de stockage. Les flux ne sont que des vues de la source de données, pas des structures de données.

Les flux sont de nature fonctionnelle. Les modifications apportées au flux ne modifient pas la source de données. Par exemple, filtrer un flux ne supprime pas les éléments filtrés, mais produit un nouveau flux qui ne contient pas les éléments filtrés. --Délai d'évaluation. Les opérations sur les flux ne sont pas effectuées immédiatement. Seulement exécuté lorsque l'utilisateur a vraiment besoin du résultat. --Peut être consommé. Les éléments de flux ne sont visités qu'une seule fois pendant la durée de vie du flux. Une fois parcouru, le flux est invalide, comme un itérateur de conteneur. Si vous souhaitez parcourir à nouveau le Stream, vous devez régénérer le nouveau Stream. Prenons un exemple pour voir ce que Stream peut faire.

Dans l'exemple précédent, nous avons pris des boules en plastique comme source de données, filtré les boules rouges et les avons fondues en triangles aléatoires. Un autre filtre supprime les petits triangles. L'agent amortissant additionne les circonférences.

Comme le montre la figure ci-dessus, un flux contient trois opérations importantes: la création de flux, les opérations intermédiaires et les opérations de terminal.

Création de flux

Dans Java 8, vous pouvez utiliser de nombreuses méthodes pour créer un flux.

1. Créez un flux en utilisant une collection existante

Dans Java 8, en plus de nombreuses classes liées aux flux, la classe de collection elle-même a été améliorée. La méthode Java 8 Stream peut convertir une collection en Stream.

List<String> strings = Arrays.asList("Hollis", "HollisChuang", "hollis", "Hello", "HelloWorld", "Hollis");
Stream<String> stream = strings.stream();

Dans l'exemple ci-dessus, nous créons un flux à partir d'une liste existante. La méthode parallelStream peut également créer un flux parallèle pour une collection.

Vous créez également souvent des flux à partir de collections.

2. Créez un flux en utilisant la méthode stream

La méthode of fournie par Stream peut être utilisée pour renvoyer directement un Stream constitué des éléments spécifiés.

Stream<String> stream = Stream.of("Hollis", "HollisChuang", "hollis", "Hello", "HelloWorld", "Hollis");

Le code ci-dessus utilise la méthode of pour créer un flux et le renvoyer.

Fonctionnement intermédiaire du flux

Les flux ont de nombreuses opérations intermédiaires qui peuvent être combinées pour former un pipeline. Chaque opération intermédiaire est comme un travailleur sur le pipeline. Chaque travailleur peut traiter un flux. L'opération intermédiaire renvoie un nouveau Stream.

Vous trouverez ci-dessous une liste des opérations intermédiaires courantes.

filter La méthode de filtrage est utilisée pour filtrer les éléments selon des critères spécifiés. L'extrait de code suivant utilise la méthode filter pour filtrer une chaîne vide.

List<String> strings = Arrays.asList("Hollis", "", "HollisChuang", "H", "hollis");
strings.stream().filter(string -> ! string.isEmpty()).forEach(System.out::println);
//Hollis, , HollisChuang, H, hollis

map La méthode map mappe chaque élément au résultat correspondant. L'extrait de code suivant utilise la méthode map pour générer le nombre carré de l'élément correspondant.

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
numbers.stream().map( i -> i*i).forEach(System.out::println);
//9,4,4,9,49,9,25

limit/skip Limit renvoie les N premiers éléments du Stream. Skip supprime les N premiers éléments de Stream. L'extrait de code suivant utilise la méthode limit pour contenir les quatre premiers éléments.

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
numbers.stream().limit(4).forEach(System.out::println);
//3,2,2,3

sorted La méthode triée trie les éléments d'un Stream. L'extrait de code suivant utilise la méthode triée pour trier les éléments d'un Stream.

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
numbers.stream().sorted().forEach(System.out::println);
//2,2,3,3,3,5,7

distinct Pour supprimer les doublons, utilisez la méthode distincte. L'extrait de code suivant utilise la méthode distincte pour dédupliquer un élément.

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
numbers.stream().distinct().forEach(System.out::println);
//3,2,7,5

Ensuite, j'expliquerai ce qui arrive à Stream après avoir effectué des opérations de filtrage, de mappage, de tri, de limite et de distinction à l'aide d'exemples et de diagrammes.

Le code est indiqué ci-dessous.

List<String> strings = Arrays.asList("Hollis", "HollisChuang", "hollis", "Hello", "HelloWorld", "Hollis");
Stream s = strings.stream().filter(string -> string.length()<= 6).map(String::length).sorted().limit(3)
            .distinct();

La figure suivante montre chaque étape et ses résultats.

Entreprise de terminal de flux

L'opération de terminal du flux renvoie également Stream. Comment convertir un flux dans le type souhaité? Par exemple, comptez les éléments d'un Stream et convertissez ce Stream en collection. Le fonctionnement du terminal est nécessaire pour ce faire.

Les opérations de terminal consomment Stream et produisent le résultat final. Autrement dit, après qu'une opération de terminal a été effectuée sur un flux, ce flux ne peut pas être réutilisé et aucune opération intermédiaire n'est autorisée sur ce flux. Sinon, une exception sera levée.

java.lang.IllegalStateException: stream has already been operated upon or closed

C'est la même chose que le sens du dicton "Vous ne pouvez pas entrer deux fois dans la même rivière".

Le tableau ci-dessous présente les opérations courantes des terminaux.

forEach La méthode forEach effectue une itération sur les éléments du flux. L'extrait de code suivant utilise forEach pour renvoyer 10 nombres aléatoires.

Random random = new Random();
random.ints().limit(10).forEach(System.out::println);

count La méthode count compte les éléments dans le Stream.

List<String> strings = Arrays.asList("Hollis", "HollisChuang", "hollis","Hollis666", "Hello", "HelloWorld", "Hollis");
System.out.println(strings.stream().count());
//7

collect Une opération de collecte est une opération de réduction qui peut accepter divers paramètres et accumuler des éléments de flux dans le résultat récapitulatif.

List<String> strings = Arrays.asList("Hollis", "HollisChuang", "hollis","Hollis666", "Hello", "HelloWorld", "Hollis");
strings  = strings.stream().filter(string -> string.startsWith("Hollis")).collect(Collectors.toList());
System.out.println(strings);
//Hollis, HollisChuang, Hollis666, Hollis

Ensuite, nous continuerons à utiliser des filtres, des cartes, des tris, des limites et des diagrammes montrant que des opérations distinctes ont été effectuées pour afficher les résultats des différentes opérations de terminal sur le Stream données dans l'exemple ci-dessus.

La figure suivante utilise un exemple pour afficher les entrées et les sorties de toutes les opérations décrites dans cet article.

Aperçu

Cet article décrit comment utiliser et fonctionnalités des flux dans Java 8. Cet article couvre également la création de flux, de flux intermédiaires et d'opérations de terminal.

Il existe deux façons de créer un flux, l'une consiste à utiliser la méthode stream de la collection et l'autre à utiliser la méthode stream's of.

Les opérations intermédiaires de flux peuvent gérer les flux. L'entrée et la sortie de l'opération intermédiaire sont des flux. Les opérations intermédiaires incluent les filtres, les cartes et les tris.

Les opérations intermédiaires de flux peuvent convertir un flux en un autre conteneur, tel que le comptage des éléments du flux, la conversion du flux en collection, l'itération des éléments du flux, etc.

Alibaba Cloud est l'opérateur d'infrastructure cloud n ° 1 (Gartner 2019) dans la région Asie-Pacifique avec deux centres de données au Japon et plus de 60 zones de disponibilité dans le monde. Cliquez ici pour plus d'informations sur Alibaba Cloud. Page officielle d'Alibaba Cloud Japan *

Traitement des données à l'aide de l'API de flux de Java 8