Filtre de flux Java

Un exemple de flux est: crayon, encre, coutumier, personnes, chat. gâteau, foresterie

Si ce flux doit être filtré, pour avoir le résultat de seuls mots dont la longueur est supérieure à cinq caractères, le résultat serait:

crayon, coutumier, personnes, foresterie

Un autre exemple de flux est:

chien, chauve-souris, nul, champ, pays, nul, superposition

Si ce flux doit être filtré pour que les valeurs nulles ne soient pas présentes, le résultat serait:

chien, chauve-souris, champ, pays, superposition

Un autre exemple de flux est:

1, 2, 3, 4, 5, 6, 7, 8

Si ce flux doit être filtré de sorte que le résultat n'a aucun nombre inférieur ou égal à 5, le résultat serait:

6, 7, 8

Un flux est une séquence d'éléments. La source du flux peut être un tableau, une collection ou une entrée à partir du disque dur ou du réseau. Le filtrage d'un flux signifie éliminer certains éléments en fonction de certains critères. De tels critères, lorsqu'ils sont codés, sont une fonction, et il est appelé un prédicat.

Contenu de l'article

• Prédicat
• Certaines structures productrices de flux
• La méthode filtre ()
• Conclusion

Prédicat

Un prédicat est une fonction qui se traduit par un vrai ou un faux. Pour le ruisseau,

crayon, encre, coutume, personnes, chat, gâteau, foresterie

Le prédicat du filtre n'a que des mots dont la longueur est supérieure à 5, peut être:

mot -> mot.le long ()> 5

Word est une variable fictive et représente chaque mot dans le flux. Une fonction comme celle-ci, avec la flèche ->, est appelée une expression de lambda. Cette fonction est interprétée comme des mots dont les longueurs sont chacune supérieures à 5. La méthode de longueur d'une classe de chaîne renvoie la longueur de la chaîne.

Les mots sont lus un par un, et pour chaque cas, si la longueur du mot est supérieure à 5, toute cette expression (de «mot» à 5) entraînerait une vraie; sinon, toute l'expression entraînerait une fausse.

Pour le ruisseau,

chien, chauve-souris, nul, champ, pays, nul, superposition

Le prédicat du filtre a des mots non nuls peut être:

mot -> mot != nul

Cette expression signifie que le mot adressé n'est pas nul.

Pour le flux d'entiers,

1, 2, 3, 4, 5, 6, 7, 8

Le prédicat du filtre, pour ne pas avoir de nombre inférieur ou égal à 5, est:

Numéro -> Numéro> = 6

où le nombre fait référence à chaque numéro (à son tour). Cela signifie que tout nombre choisi doit être supérieur ou égal à 6.

En filtrant les éléments d'un flux, ce n'est pas seulement le codage de prédicat que le programmeur doit connaître. Le programmeur doit également savoir quelles structures produisent un flux et comment un flux est produit. Le tableau ou la collection est une source de flux. N'oubliez pas que les opérations d'entrée / sortie de l'ordinateur peuvent également produire un flux; Cependant, cet article ne traite pas de cela.

Certaines structures productrices de flux

Déployer

Les tableaux sont une classe destinée à gérer les tableaux. Les méthodes de tableaux prennent un tableau réel comme l'un de ses arguments. Les tableaux, en tant que classe, ont la méthode suivante:

STATIQUE PUBLIQUE Liste aslist (t… a)

Ceci est une méthode statique, ce qui signifie que l'objet des tableaux n'est pas instancié. Cette méthode renvoie une liste. La liste peut être considérée comme un flux non filtré ou filtré, mais ce n'est pas un vrai flux. Par exemple, dans la déclaration suivante, le LST produit à partir d'une source brute d'entiers est comme un flux non filtré:

Liste LST = tableaux.aslist (1, 2, 3, 4, 5, 6, 7, 8);

L'objet de liste a une méthode pour produire un flux non filtré avec les mêmes éléments de liste, mais en tant que flux - voir ci-dessous.

Collection

Les exemples de collections sont ArrayList et Vector. La liste elle-même est une collection à usage général.

Liste des tableaux

ArrayList, en tant que classe, a la méthode suivante:

flux par défaut flux()

Cette méthode renvoie un objet Stream. Le segment de code suivant l'illustre:

Liste des tableaux Al = Nouveau ArrayList();
Al.Ajouter ("chien"); Al.ajouter ("bat"); Al.ajouter (null); Al.ajouter le champ");
Al.Ajouter ("pays"); Al.ajouter (null); Al.ajouter ("superposition");
Flux Stre = al.flux();

Stre est un ruisseau non filtré.

Liste

La liste est en fait une interface; ce n'est pas une classe. Cependant, son objet peut être renvoyé par la méthode des tableaux statiques, aslist (), comme indiqué ci-dessus. L'objet liste a la méthode Stream (), qui est comme celle de l'objet ArrayList. Le segment de code suivant montre comment l'objet Liste peut renvoyer un flux:

Vecteur vtr = nouveau vecteur();
vtr.ajouter ("crayon"); vtr.ajouter ("encre"); vtr.ajouter ("coutumier"); vtr.ajouter des personnes");
vtr.ajouter ("chat"); vtr.ajouter ("gâteau"); vtr.ajouter ("foresterie");
Liste lst = vtr.subliste (0, vtr.taille());
Flux Stre = LST.flux();

L'objet de liste ici est renvoyé par la méthode sublist () du vecteur.

Remarque: la classe Arrays, la classe ArrayList, la classe vectorielle et l'interface de liste sont dans le Java.user.* package, qui doit être importé. Cependant, l'interface de flux est dans le java.user.flux.* package (minuscules 's'), qui doit également être importé.

La méthode filtre ()

Ainsi, un objet ArrayList ou un objet de liste peut produire un flux en utilisant leurs méthodes Stream (). Qu'est-ce qui peut produire un objet de liste? La classe des tableaux et la classe vectorielle peuvent chacun produire un objet de liste. La classe Arrays utilise sa méthode ASSList (), et la classe vectorielle utilise sa méthode sublist ().

Le flux est une interface et non une classe. L'objet Stream est renvoyé par la méthode Stream de l'objet de liste ou de l'objet ArrayList. L'objet Stream a la méthode Filter () pour le filtrage. Son argument est le prédicat. Le nouveau flux renvoyé par la méthode du filtre est le flux filtré.

L'objet Stream a de nombreuses méthodes. Deux d'entre eux sont: Count () et ForEach (). La méthode Count () renvoie le nombre d'éléments dans le flux, et la méthode foreach () est utilisée pour scanner les éléments de flux.

Le programme Java devrait commencer:

Importer Java.user.*
Importer Java.user.flux.*

Filtrage pour les cordes supérieures à une longueur

Le code suivant montre comment faire ceci:

Vecteur vtr = nouveau vecteur();
vtr.ajouter ("crayon"); vtr.ajouter ("encre"); vtr.ajouter ("coutumier"); vtr.ajouter des personnes");
vtr.ajouter ("chat"); vtr.ajouter ("gâteau"); vtr.ajouter ("foresterie");
Liste lst = vtr.subliste (0, vtr.taille());
Flux Stre = LST.flux();
Flux STREA = Stre.filtre (mot -> mot.length ()> 5);
basse.foreach (élément -> système.dehors.print (élément + ""));
Système.dehors.println ();

La méthode foreach () a pris une fonction lambda, dont cette fois, ce n'est pas un prédicat. La sortie filtrée est:

crayon des gens habituels foresterie

Filtrage des valeurs nulles

Le code suivant montre comment il peut être fait:

Liste des tableaux Al = Nouveau ArrayList();
Al.Ajouter ("chien"); Al.ajouter ("bat"); Al.ajouter (null); Al.ajouter le champ");
Al.Ajouter ("pays"); Al.ajouter (null); Al.ajouter ("superposition");
Flux Stre = al.flux();
Flux STREA = Stre.filtre (mot -> mot != null);
basse.foreach (élément -> système.dehors.print (élément + ""));
Système.dehors.println ();

La sortie est:

Superposition country de champ de chauve-souris pour chiens

Filtrage pour les plus grands entiers

Le code suivant illustre ceci:

Liste LST = tableaux.aslist (1, 2, 3, 4, 5, 6, 7, 8);
Flux Stre = LST.flux();
Flux STREA = Stre.filtre (nombre -> nombre> = 6);
basse.foreach (élément -> système.dehors.print (élément + ""));
Système.dehors.println ();

La sortie est:

6 7 8

Conclusion

La classe Arrays peut produire un objet de liste avec sa méthode ASSList (). La classe vectorielle peut produire un objet de liste avec sa méthode sublist (). Les objets List et ArrayList ont chacun la méthode Stream (). La méthode du flux renvoie le flux non filtré. L'objet Stream renvoyé a la méthode filtre () qui prend un prédicat (critères de filtrage). La méthode du filtre renvoie le flux filtré.