Collectionneur de cours d'eau Java
Exemple 1:
La méthode collection () est utilisée pour générer la liste dans l'exemple suivant. La mise en œuvre du collecteur qui crée une nouvelle liste à partir des éléments d'entrée est renvoyée par les collectionneurs.Méthode Tolist ().
Importer Java.user.flux.Collectionneurs;Importer Java.user.Liste;
Importer Java.user.Liste des tableaux;
Perfume de classe
int pid;
String pname;
float pprice;
Public Perfume (int pid, string pname, float pprice)
ce.pid = pid;
ce.pname = pname;
ce.pprice = pprice;
collectionneurs de classe publique1
public static void main (String [] args)
ListPerFumesList = new ArrayList ();
Parfum.Ajouter (nouveau parfum (1, "Garden of Roses.", 5000f));
Parfum.Ajouter (nouveau parfum (2, "terrassement des merveilles", 4000f));
Parfum.Ajouter (nouveau parfum (3, "Berry Mellow.", 18000f));
ListPerFumespriceList =
Parfum.flux()
.Carte (i-> i.pprice)
.Recueillir (collectionneurs.lister());
Système.dehors.println (perfumespriceList);
Nous définissons une classe de «parfums» où ses attributs sont déclarés «pname», «pid» et «pprice». Ensuite, nous appelons ces attributs à l'intérieur du constructeur de la fonction «Perfumes» comme un paramètre et faisons référence aux attributs actuels de cette fonction à l'aide du mot-clé «This». Après cela, nous construisons la classe principale «Collector1» du programme où le programme principal de cet exemple est déployé. Ici, nous définissons l'interface de liste pour la classe «Perfumes» pour créer la liste dans la variable «Perfumeslist» déclarée. La liste comprend les différentes valeurs pour l'ID de parfum, le nom et le prix qui sont ajoutés via ADD (). Ensuite, nous générons la liste «parfumeliste» où la «parfumeste» est appelée avec la méthode Stream () pour générer le flux de valeurs de parfum. Après cela, nous utilisons la méthode map () pour obtenir la liste des prix des parfums. La classe Collect est déployée qui prend les collectionneurs.tolist () pour percevoir les prix de la liste des parfums et imprimer cette liste qui ne contient que les prix.
La liste des prix des parfums de classe est récupérée à l'aide des collectionneurs.Méthode Tolist ().
Exemple 2:
La classe Java Collector fournit des opérations différentes pour la réduction. La méthode de jointure () de la classe Java Collectors est utilisée pour combiner les plusieurs éléments d'un caractère de caractère ou de chaîne dans un objet spécifique. Cette technique accomplit cela via le flux. La classe de collection comprend plusieurs surcharges de méthode de jointure.
Importer Java.user.Liste;Importer Java.user.flux.Collectionneurs;
collectionneurs de classe publique2
public static void main (String [] args)
var myfriends = liste.de ("William", "James", "Noah", "Oliver",
"Lucas", "Liam", "Benjamin");
var joinList = Myfriends.flux().Recueillir (collectionneurs.joindre(","));
Système.dehors.printf ("Join String List:% s", joinList);
Nous avons une déclaration variable «Myfriends» qui s'appelle la liste.de () méthode pour avoir une simple implémentation immuable de la classe de liste. La liste est fournie avec les différents éléments de chaîne. Après cela, nous déclarons une variable de «liste de jointure» qui crée d'abord le flux de la liste «Myfriends». Ensuite, la méthode Collect () invoque la méthode des collectionneurs Joining (). Les collectionneurs.La méthode joint () rejoint la liste sous la forme d'une chaîne en utilisant la virgule «», qui est transmise comme argument. La liste jointe de la chaîne est ensuite imprimée sur la console.
La sortie qui montre la liste spécifiée est rejointe par les collectionneurs.Méthode rejointe ().
Exemple 3:
La méthode statique de la classe des collectionneurs résumant () renvoie les statistiques des résultats obtenus après un ensemble de valeurs d'entrée donnée à l'implémentation fournie à ToIntFunction ().
Importer Java.user.Tableaux;Importer Java.user.Intsummarystatistics;
Importer Java.user.Liste;
Importer Java.user.flux.Collectionneurs;
Importer Java.user.flux.Flux;
collectionneurs de classe publique3
public static void main (String [] args)
Listnumlist = arrays.aslist (13, 25, 18, 18);
Système.dehors.println ("Number Ist -" + numList);
StreamnumStream = numlist.flux();
IntsummarystatisticsNumsummary = numstream.Recueillir (collectionneurs.résumerInTInt (i -> i));
Système.dehors.println ("statistiques de résumé des flux de nombres -" + numsummary);
Nous déclarons l'objet de classe «numList» de liste où le tableau de la liste des entiers est spécifié à l'aide de la méthode ASSList (). La liste du tableau des entiers s'affiche avec la déclaration d'impression. Après cela, nous créons le flux de ce tableau de liste en invoquant la méthode Stream () avec la variable «numlist» dans la variable «numstream» de la classe Stream. Ensuite, nous appelons la classe Intsummarystatistics et déclarons l'objet «numsummary» où la méthode collection () obtient le résumé de la liste des tableaux à partir de la méthode SummarizingInt () et imprime ce résumé lors de l'exécution du programme.
Le résumé statistique de la liste des tableaux précédents s'affiche dans ce qui suit. Il étend la somme, la valeur minimale, la valeur maximale et la valeur moyenne.
Exemple 4:
La méthode de groupement de Java () de la classe des collectionneurs est utilisée pour regrouper les éléments en fonction d'un attribut et stocker les données dans un objet MAP. De plus, les éléments totaux qui sont donnés en tant que paramètre dans le flux peuvent également être comptés en utilisant la méthode de comptage () des collectionneurs qui est passé à l'intérieur de la méthode GroupingBy (). La fonction renvoie un collecteur qui accepte les éléments de type T et collecte le nombre d'éléments entrants. Le résultat de la méthode comptage () est nul s'il n'y a pas d'éléments.
Importer Java.user.Tableaux;Importer Java.user.Liste;
Importer Java.user.Carte;
Importer Java.user.fonction.Fonction;
Importer Java.user.flux.Collectionneurs;
collectionneurs de classe publique4
public static void main (String [] args)
Lister les villes =
Tableaux.Aslist ("Phoenix", "Houston",
"New York", "Phoenix", "San Diego", "Houston");
Mapmymap =
Villes.flux().collecter(
Collectionneurs.groupement par
Fonction.identité (), collectionneurs.compte()));
Système.dehors.println (mymap);
Nous créons la liste des tableaux avec la méthode ASSList () et insérons les noms des villes uniques et répétées. Cette liste est déclarée dans la variable «villes» de la classe de liste. Après cela, nous avons une interface de carte qui déclare l'objet «MyMap». Grâce à cette interface de carte, nous obtenons le flux de la liste fournie. Ensuite, nous utilisons la méthode Collect () qui utilise en outre la méthode de classement de classe collector par. La méthode GroupingBy () regroupe les éléments de la liste en les identifiant d'abord en utilisant la fonction.Méthode identifier (). Ensuite, il compte le nombre d'éléments donnés en utilisant la méthode comptage () de la classe des collectionneurs. Les éléments groupés après le traitement via les méthodes de classe de collection sont affichés par l'instruction PRINT.
La liste suivante est la forme du groupe. L'élément qui est répété dans la liste est regroupé avec la valeur de «2». L'élément unique a la valeur de «1».
Exemple 5:
La classe des collectionneurs contient une autre définition de méthode pour la collection et letThen (). La méthode de collection statique et de) de la classe des collectionneurs produit d'abord les résultats de l'opération du collecteur. Ensuite, l'autre transformation de finition supplémentaire est effectuée.
Importer Java.user.Collections;Importer Java.user.Liste;
Importer Java.user.flux.Collectionneurs;
Importer Java.user.flux.Flux;
collectionneurs de classe publique5
public static void main (String [] args)
StreamStreMelements = Stream.de ("un", "deux", "trois");
ListSynclist = streamements.Recueillir (collectionneurs.Collecte et then (
Collectionneurs.Tolist (), Collections :: SynchronizedList));
Système.dehors.println (synclist);
Le flux de la chaîne est défini dans la variable «diffusion» de la classe de flux. Nous fournissons ensuite l'objet de liste «Synclist» pour la synchronisation de la liste. La méthode Collect est appliquée au flux «Streamements». La méthode Collect () comprend la méthode CollectionAndThen () qui est en outre utilisée avec la méthode Tolist (). Cependant, nous avons besoin d'une liste immuable. Ainsi, nous utilisons la méthode UnmodifiablesSet () sur la liste générée pour renvoyer une représentation non modifiable de la liste. Ensuite, nous imprimons la liste non modifiable de la console.
La sortie du programme précédente est exécutée dans l'image de la console Java suivante:
Conclusion
La méthode Java Stream Collect () est principalement utilisée pour ajouter les éléments de flux aux collections. Les éléments du flux sont traités vers une procédure de réduction modifiable. Les processus de réduction séquentiels et simultanés sont possibles. Dans le cas d'un flux parallèle, il gère la synchronisation. La classe des collectionneurs propose de nombreuses implémentations de collection pour nous aider. Quelques-unes des méthodes de la classe de collection sont mises en œuvre dans cet article.