Java Avancé : Streams

Name: Java Avancé : Streams
Author: Scott Stanlick

Apprenez à utiliser vos connaissances en programmation fonctionnelle en créant des pipelines avec des flux

Preview the first lesson free — get full access to all 3 lessons.

Cours : à la demande

Dans cette leçon, nous allons jeter un œil au niveau du support de streaming dans la bibliothèque Java.utility. Nous allons jeter un œil au pipeline, points terminaux, filtrage, mappage, regroupement réduire, classer les statistiques, et nous finirons par examiner les let. Dans cette leçon particulière, nous allons jeter un œil aux points de terminaison des pipelines et des terminaux. Donc, si vous pouvez voir le graphique ici, nous commençons avec une source de flux, qui peut concerner n'importe quoi. Il s'agit généralement d'un type de collection, une liste, une carte, une file d'attente. Il peut s'agir d'un tableau, d'un canal IO. Cela peut être n'importe quel nombre de choses. Et nous demandons à cette source de flux de se présenter sous forme de flux à l'aide de la méthode de flux. À ce moment, il y a un nombre quelconque d'opérations intermédiaires que nous pouvons effectuer sur le flux. Vous avez peut-être entendu le terme réduction de carte ou transformation de carte. C'est cette idée. Nous pouvons filtrer, trier, convertir, cartographier, beaucoup d'opérations différentes que nous considérons ces opérations intermédiaires comme étant, nous pouvons effectuer sur ce flux. Maintenant, rien ne se passe réellement jusqu'à ce que nous atteignions l'opération terminale, ce que nous verrons pourrait être, Je voudrais la collection maintenant être présenté comme une collection après avoir été transformé et réduit et ainsi de suite ou peut-être juste un agrégat, un compte ou une somme, ou des statistiques comme nous le verrons. Donc la première chose que je veux faire, juste pour commencer un peu ici avec l'idée, J'ai une collection ici qui se trouve être une liste de fruits. Et vous pouvez les voir ici. Et ce que nous aurions pu faire avant Streams aurait été l'approche impérative. Nous avons peut-être parcouru la liste en boucle. Et dans ce cas, on cherche chaque fruit qui se termine par la lettre e. Donc pomme, oui, oranges, non, ananas, oui, et vous pouvez voir. Alors on pourrait dire, si le fruit se termine par la lettre e puis ajoutez ce fruit particulier à la liste filtrée. Et puis on y va. A la fin, on devrait se retrouver avec pomme, ananas., et, eh bien, il y avait deux pommes ici. Maintenant, en utilisant Streams, c'est un peu plus déclaratif. Nous pouvons donc commencer avec la même liste de fruits que nous avions il y a un instant. Et dans ce cas, on va demander à la collection, dans ce cas la liste, se présenter à nous comme un Flux. À ce moment-là, nous pouvons commencer à tirer ces opérations intermédiaires. Et ici, vous pouvez voir que je vais utiliser la méthode du filtre. Je vais utiliser l'expression lambda ici, tel que je voudrais filtrer le flux pour n'inclure que les fruits qui se terminent par la lettre e. Et puis l'opérateur du terminal que vous voyez ici est de collecter tout ce qui a traversé le filtre ici, rassemblez-le dans une liste. Et je les reçois dans quelque chose appelé filteredList. Donc, vous pouvez voir que mon affirmation est la même qu'avant, sauf que je n'ai pas écrit de boucles ou que je n'ai pas fait de si ou créer des listes temporaires ou ajouter à la liste temporaire, rien de cela. Je viens d'utiliser le support de flux et la programmation déclarative. Vous voyez donc que c'était très efficace. Nous pouvons gérer n'importe quel ensemble d'éléments de taille dans le flux, très efficace en mémoire. Rien ne s'est passé jusqu'à ce que nous atteignions le point de terminaison terminal. Et je veux jeter un oeil à quelques autres idées ici, un dans lequel j'ai une collection qui compte des centaines de milliers de points, géolocalisations, en elle. Et j'aimerais faire quelques choses. Il semble, d'abord, Je vais lire toutes les géolocalisations. Ce type contient 30 406 éléments. Ce que je voudrais faire maintenant est, avec cette même collection de points de géolocalisation, c'est le transformer en ruisseau. En d'autres termes, demandez-lui de se présenter à moi comme un flux. Et puis je vais émettre cet opérateur intermédiaire de filtre. Je vais filtrer uniquement les géolocalisations où la population était supérieure à 50 000 puis rassemblez-le dans une liste. Vous pouvez donc voir ici que les plus grandes populations, il n'y avait que 951 géolocalisations sur 30 406 qui comptait plus de 50 000 habitants. Maintenant la notion suivante ici, nous avons utilisé le .stream pour transformer la collection, dans ce cas, en un flux. Si nous avons des centaines de milliers ou des millions ou des dizaines de millions d'éléments dans le flux, nous pouvons tout aussi bien utiliser l'opération parallelStream. Et ce que ça fait, c'est qu'il s'éteint pour voir combien de cœurs vous avez, combien de processeurs sur la machine, et cela créera sous le tapis autant de threads qu'il y a de cœurs sur votre plateforme. Et puis ce qu'il fait, c'est bifurquer/joindre Ou quelque chose du genre de sorte qu'il puisse sortir et déterminer combien de populations ont plus de 50 000 habitants en utilisant autant de threads que vous avez de cœurs sur votre machine. Cela permet donc des calculs parallèles très faciles sans avoir à se soucier du multi-threading et faire toutes ces choses nous-mêmes. Et la dernière chose que je vais juste te montrer, Je pensais que cela était intéressant. Si vous voulez entrer et voir à quoi ça ressemble à différents points de votre pipeline, ils nous ont donné une méthode de coup d'oeil. Maintenant, la seule chose que je peux comprendre à ce sujet est-ce qu'ils mettent ça ici pour les développeurs. Donc je vais filtrer mon flux de fruits ici, ces fruits qui se terminent par la lettre minuscule e puis le coup d'œil s'attend à ce que vous le passiez en tant que consommateur. Donc mon consommateur est, Je vais consommer les éléments qui a traversé cette partie du filtre, à travers cette partie du pipeline et imprimez-le. Et puis je vais cartographier n'importe quel fruit qui l'a fait à travers ce filtre jusqu'au nom du fruit tout en majuscules. Et vous pouvez voir que nous pouvons mettre ces opérations de coup d'œil là-dedans à un certain nombre d'endroits le long du pipeline. Et puis, finalement, je le collectionne dans une liste et vous pouvez voir que ce que je devrais avoir dans le résultat final est POMME, ANANAS et POMME à nouveau tout en majuscule, parce qu'il a été filtré et il a été transformé ou mappé à la version majuscule. J'apprécie donc que vous regardiez. Merci beaucoup.

Avancé Fournisseur : Scott Stanlick 3 leçons · 18m en Arabe, Allemand, Anglais, Espagnol, Français, Portugais, Chinese

Description du cours

Dans ces leçons, nous examinerons le traitement des flux d'objets, communément appelés leurs éléments. Un flux peut être de taille limitée ou infinie par rapport à son nombre d'éléments, et peut être obtenu à partir de nombreuses sources, voire de générateurs disponibles dans le langage de programmation Java. Nous verrons comment traiter les flux très volumineux à l'aide du traitement parallèle, dans lequel tous les cœurs disponibles sur votre machine participent au traitement des flux.

Vous apprendrez à quel point il est facile de combiner vos connaissances du framework de collecte, de la programmation fonctionnelle et des expressions lambda pour créer des pipelines déclaratifs, capables de résoudre la myriade de problèmes rencontrés quotidiennement dans le développement de logiciels. Qu'il s'agisse de filtrer des éléments d'un flux ou de mapper les éléments sur un type différent, le traitement de flux peut simplifier la résolution de problèmes. Nous terminerons en appliquant des limites, des statistiques, en ordonnant, en améliorant et en réduisant un flux à tout ce dont nous avons besoin pour produire des résultats pour les clients.

Ce que vous allez apprendre

Décrire ce qu'est un flux (stream) et où l'on peut les trouver ou les obtenir
Construire des pipelines logiques et déclaratifs à l'aide d'expressions lambda et de points de pipeline et de points terminaux (terminal points)
Appliquer des opérations de filtrage, de mappage, de regroupement et de réduction aux éléments du flux
Produire des statistiques à partir d'un flux et traiter le classement et les limites
Utiliser le traitement en parallèle (parallel processing) pour traiter de très grands flux sur l'ensemble des cœurs disponibles
Combiner le framework des collections, la programmation fonctionnelle et les expressions lambda pour résoudre des problèmes

Points clés à retenir

Un flux traite une séquence d'objets (éléments) et peut être de taille limitée ou infinie, obtenu à partir de nombreuses sources ou générateurs en Java.
Le traitement des flux prend en charge le traitement en parallèle, ce qui permet à tous les cœurs disponibles d'une machine de participer au traitement de flux très importants.
Les pipelines déclaratifs sont construits en combinant le framework de collections, la programmation fonctionnelle et les expressions lambda.
Les opérations courantes sur les flux incluent le filtrage d'éléments, le mappage d'éléments vers un type différent, le regroupement et la réduction.
Les flux peuvent être affinés davantage en appliquant des limites, des statistiques, un classement, une amélioration et une réduction pour produire les résultats finaux.

Foire aux questions

Que couvre ce cours ?

Il couvre le traitement de flux d'objets en Java, y compris la construction de pipelines avec des points de pipeline et des points terminaux ; le filtrage, le mappage, le regroupement et la réduction d'éléments ; et le travail avec l'ordre, les statistiques et les limites. Il couvre également l'utilisation du traitement en parallèle pour les très grands flux.

Quelles compétences vais-je acquérir grâce à ce cours ?

Le cours se concentre sur l'application streaming, Java 8, Java 11, les processeurs de flux (stream processors) et le traitement des flux (stream processing) dans le langage de programmation Java.

Ce cours aborde-t-il le traitement des flux très volumineux ?

Oui. Il explique comment gérer des flux très importants à l'aide du traitement en parallèle, par lequel tous les cœurs disponibles de votre machine participent au traitement du flux.

Sur quelles connaissances le cours s'appuie-t-il ?

Il s'appuie sur et combine vos connaissances du framework des collections, de la programmation fonctionnelle et des expressions lambda pour créer des pipelines déclaratifs.

Quels sujets sont enseignés dans les leçons ?

Les leçons couvrent les points de pipeline et terminaux ; le filtrage, le mappage, le regroupement et la réduction ; ainsi que l'ordre, les statistiques et les limites.