Java 8 appliquer la fonction à tous les éléments de Flux sans rupture de flux de la chaîne d'

Est-il un moyen en Java pour appliquer une fonction à tous les éléments d'une Stream sans casser la Stream de la chaîne? Je sais que je peux appeler forEach, mais cette méthode renvoie une void, pas un Stream.

La méthode que vous voulez invoquer le retour de la valeur?
pouvez-vous expliquer ce que vous entendez par without breaking the stream chain? peut-être un exemple?
Alex signifie quelque chose comme mon confectionnés apply méthode ici: things.stream().apply(o -> o.status = newStatus).map(....).... Même idée que forEach, mais ne pas "briser la chaîne", par exemple, renvoie une Stream<T> au lieu de void.

OriginalL'auteur alexgbelov | 2017-05-05

  1. 20

    Il y a (au moins) 3 façons. Pour le bien d'un exemple de code, j'ai supposé que vous voulez l'appeler 2 consommation méthodes methodA et methodB:

    A. Utiliser peek():

    list.stream().peek(x -> methodA(x)).forEach(x -> methodB(x));

    Bien que les docs disent que seule l'utilisation de "debug", ça marche (et c'est dans la production dès maintenant)

    B. Utilisation map() appeler methodA, puis retourner l'élément de retour vers le stream:

    list.stream().map(x -> {method1(x); return x;}).forEach(x -> methodB(x));

    C'est probablement le plus "acceptable".

    C. Faire deux choses à la forEach():

    list.stream().forEach(x -> {method1(x); methodB(x);});

    C'est le moins flexible et peut ne pas convenir à votre besoin.

    Les conséquences de l'exécution d'une action avec des effets secondaires dans map’s de la fonction et de l'aide peek pour un (non-debug) effet secondaire, sont fondamentalement les mêmes.
    qui a dit quelque chose à propos des effets secondaires?
    L'invocation de method1(x); serait tout à fait inutile, si elle n'avait pas d'effets secondaires.
    incorrect. Method1 peut faire quelque chose avec elle, sans mutation. En fait, j'ai utilisé ce modèle exact (le pic de la version) quand j'ai voulu recueillir les éléments d'un Ensemble, pas de timing critique, c'est à dire pas de problème), partiellement, par le biais d'un flux, mais aussi envoyer la queue du flux de données pour un consommateur via un forEach(). Pas inutile.
    Votre définition de “effets secondaires” ne correspond pas à la définition du reste du monde de l'informatique. C'est particulièrement dangereux, comme l'API de la documentation, comme le Flux de l'API, en décourageant les effets secondaires dans les fonctions de, se réfèrent à la définition standard, par exemple Wikipédia: “En informatique, une fonction ou une expression est dit d'avoir un effet secondaire s'il modifie certains etat en dehors de son champ d'application ou a observer une interaction avec ses fonctions d'appel ou le monde extérieur”. Il est sans pertinence de savoir si elle est intentionnelle ou inattendus.

    OriginalL'auteur Bohemian

  2. 4

    Vous êtes à la recherche pour le Stream's map() fonction.

    exemple:

    List<String> strings = stream
.map(Object::toString)
.collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
    Si j'utilise une carte, je vais devoir utiliser plusieurs lignes. quelque chose comme myStream.carte(obj -> {obj.foo(); return obj;}). Je me demandais si il y a une solution en ligne.
    Vous pouvez également consulter une méthode de là, vérifier mon mod.
    La carte est pas le bon endroit pour prendre des mesures sur l'élément du flux, c'est pour la "conversion" d'un point à quelque chose d'autre.

    OriginalL'auteur csenga

  3. 1

    Pas entièrement sûr de ce que vous entendez par breaking the stream chain, mais toute opération sur une Stream qui renvoie un Stream ne pause ou consommer votre Flux. Les flux sont consommés par terminal operations et comme vous l'avez noté le forEach ne retourne pas un Stream<T> et en tant que tel se termine le flux, par l'exécution de tous les intermediate opérations avant le forEach et le forEach lui-même.

    Dans l'exemple que vous avez fournies dans les commentaires:

     myStream.map(obj -> {obj.foo(); return obj;}

    Vous ne pouvez pas vraiment faire cela avec un liner. Bien sûr, vous pourriez utiliser une méthode de référence, mais ensuite retournés Stream serait d'un type différent (en supposant que foo retourne un type):

      myStream.map(Obj::foo) //this will turn into Stream<T>, where T is 
           //the return type of foo, instead of Stream<Obj>

    D'ailleurs que votre map opération est stateful, ce qui est fortement déconseillé. Votre code de compiler et peut même fonctionner comme vous le souhaitez - mais cela pourrait échouer. map opérations doivent être stateless.

    OriginalL'auteur Eugene

  4. 1

    La meilleure option que vous avez est d'appliquer la carte à votre flux. qui renvoie un flux de données comprenant les résultats de l'application de la donnée, la fonction de l'un des éléments de ce flux par exemple:

    IntStream.rangeClosed(40, 70).limit(20).mapToObj(i -> (Integer) i).map(item->item+3).map(item->item*2)...

    (Flux d'éléments de type StreamItemABC)

    Nous sommes l'application de plusieurs modifications dans le flux, mais de cette façon, nous ne pouvons pas nous passer des arguments à la méthode map, pour résoudre le problème:

    private void applyMethod(ParameterX parX) {
 someStreamX().map(n -> methodX(n, parX))...
}

private StreamItemABC methodX (StreamItemABC item, ParameterX parX) {
  return notification;
}

    OriginalL'auteur Mr.Q

  5. 0

    Je pense que vous êtes à la recherche pour Stream.coup d'oeil. Mais lire les docs avec soin, car il a été conçu principalement comme une méthode de débogage. À partir de la documentation:

    Cette méthode existe principalement en charge le débogage, où vous voulez voir les éléments comme ils l'écoulement d'un certain point dans un pipeline

    L'action passée à peek doit être non interférents.

    OriginalL'auteur Federico Peralta Schaffner