How to avoid nested forEach calls?

The name of the pictureThe name of the pictureThe name of the pictureClash Royale CLAN TAG#URR8PPP












9














I have the following code:



interface Device 
// ...
boolean isDisconnected();
void reconnect();


interface Gateway
// ...
List<Device> getDevices();


...

for (Gateway gateway : gateways)
for(Device device : gateway.getDevices())
if(device.isDisconnected())
device.reconnect();





I want to refactor the code using Stream API. My first attempt was like the following:



gateways
.stream()
.forEach(
gateway ->
gateway
.getDevices()
.parallelStream()
.filter(device -> device.isDisconnected())
.forEach(device -> device.reconnect())
;

)
;


I didn't like it so after some modifications I ended up with this code:



gateways
.parallelStream()
.map(gateway -> gateway.getDevices().parallelStream())
.map(stream -> stream.filter(device -> device.isDisconnected()))
.forEach(stream -> stream.forEach(device -> device.reconnect()))
;


My question is whether there is a way to avoid nested forEach.










share|improve this question




























    9














    I have the following code:



    interface Device 
    // ...
    boolean isDisconnected();
    void reconnect();


    interface Gateway
    // ...
    List<Device> getDevices();


    ...

    for (Gateway gateway : gateways)
    for(Device device : gateway.getDevices())
    if(device.isDisconnected())
    device.reconnect();





    I want to refactor the code using Stream API. My first attempt was like the following:



    gateways
    .stream()
    .forEach(
    gateway ->
    gateway
    .getDevices()
    .parallelStream()
    .filter(device -> device.isDisconnected())
    .forEach(device -> device.reconnect())
    ;

    )
    ;


    I didn't like it so after some modifications I ended up with this code:



    gateways
    .parallelStream()
    .map(gateway -> gateway.getDevices().parallelStream())
    .map(stream -> stream.filter(device -> device.isDisconnected()))
    .forEach(stream -> stream.forEach(device -> device.reconnect()))
    ;


    My question is whether there is a way to avoid nested forEach.










    share|improve this question


























      9












      9








      9


      4





      I have the following code:



      interface Device 
      // ...
      boolean isDisconnected();
      void reconnect();


      interface Gateway
      // ...
      List<Device> getDevices();


      ...

      for (Gateway gateway : gateways)
      for(Device device : gateway.getDevices())
      if(device.isDisconnected())
      device.reconnect();





      I want to refactor the code using Stream API. My first attempt was like the following:



      gateways
      .stream()
      .forEach(
      gateway ->
      gateway
      .getDevices()
      .parallelStream()
      .filter(device -> device.isDisconnected())
      .forEach(device -> device.reconnect())
      ;

      )
      ;


      I didn't like it so after some modifications I ended up with this code:



      gateways
      .parallelStream()
      .map(gateway -> gateway.getDevices().parallelStream())
      .map(stream -> stream.filter(device -> device.isDisconnected()))
      .forEach(stream -> stream.forEach(device -> device.reconnect()))
      ;


      My question is whether there is a way to avoid nested forEach.










      share|improve this question















      I have the following code:



      interface Device 
      // ...
      boolean isDisconnected();
      void reconnect();


      interface Gateway
      // ...
      List<Device> getDevices();


      ...

      for (Gateway gateway : gateways)
      for(Device device : gateway.getDevices())
      if(device.isDisconnected())
      device.reconnect();





      I want to refactor the code using Stream API. My first attempt was like the following:



      gateways
      .stream()
      .forEach(
      gateway ->
      gateway
      .getDevices()
      .parallelStream()
      .filter(device -> device.isDisconnected())
      .forEach(device -> device.reconnect())
      ;

      )
      ;


      I didn't like it so after some modifications I ended up with this code:



      gateways
      .parallelStream()
      .map(gateway -> gateway.getDevices().parallelStream())
      .map(stream -> stream.filter(device -> device.isDisconnected()))
      .forEach(stream -> stream.forEach(device -> device.reconnect()))
      ;


      My question is whether there is a way to avoid nested forEach.







      java collections foreach java-8 java-stream






      share|improve this question















      share|improve this question













      share|improve this question




      share|improve this question








      edited Dec 18 at 5:41









      candied_orange

      4,2571647




      4,2571647










      asked Dec 17 at 22:05









      Hans van Kessels

      8311




      8311






















          3 Answers
          3






          active

          oldest

          votes


















          15














          You should flatten the stream of streams using flatMap instead of map:



          gateways
          .parallelStream()
          .flatMap(gateway -> gateway.getDevices().parallelStream())
          .filter(device -> device.isDisconnected())
          .forEach(device -> device.reconnect());



          I would improve it further by using method references instead of lambda expressions:



          gateways
          .parallelStream()
          .map(Gateway::getDevices)
          .flatMap(List::stream)
          .filter(Device::isDisconnected)
          .forEach(Device::reconnect);





          share|improve this answer






















          • Thank you, it works! Does the code with method references have the same performance as the first one? It looks pretty elegant.
            – Hans van Kessels
            Dec 17 at 22:15






          • 3




            Yes, it does. Please read this post for more detailed explanation.
            – ETO
            Dec 17 at 22:17


















          11














          Don't refactor your code into using Streams. You gain no benefits and gain no advantages over doing it like this, since the code is now less readable and less idiomatic for future maintainers.



          By not using streams, you avoid nested forEach statements.



          Remember: streams are meant to be side-effect free for safer parallelization. forEach by definition introduces side-effects. You lose the benefit of streams and lose readability at the same time, making this less desirable to do at all.






          share|improve this answer






















          • Thanks for your answer. This is just my in-home project. I'm trying to learn Stream API by doing some pseudo-real tasks.
            – Hans van Kessels
            Dec 17 at 22:11







          • 5




            One way to learn about the Stream API is to know when not to apply it. This feels like one of those times, especially since you're not guaranteed that the operations you're performing inside of the stream are side-effect free which would make parallelization safe.
            – Makoto
            Dec 17 at 22:12






          • 8




            I think with ETO's answer above with flatMap, that the stream version is prettier and cleaner than the non-stream version.
            – Mateen Ulhaq
            Dec 18 at 7:40










          • @MateenUlhaq: This isn't about writing "pretty" code. This is about idiomatic code. Streams have the ability to be parallelized. If you use forEach or any terminating operand with side effects, the ability to parallelize your code weakens substantially. If you wanted to do this in parallel, you'd want a different structure to it to ensure that the operation around Device#reconnect was actually thread-safe. Doing it like this doesn't give you that assurance.
            – Makoto
            Dec 18 at 17:18



















          3














          I would try this with a sequential stream before using a parallel one:



          gateways
          .stream()
          .flatMap(gateway -> gateway.getDevices().stream())
          .filter(device -> device.isDisconnected())
          .forEach(device -> device.reconnect())
          ;


          The idea is to create a stream via gateways.stream() then flatten the sequences returned from gateway.getDevices() via flatMap.



          Then we apply a filter operation which acts like the if statement in your code and finally, a forEach terminal operation enabling us to invoke reconnect on each and every device passing the filter operation.



          see Should I always use a parallel stream when possible?






          share|improve this answer






















            Your Answer






            StackExchange.ifUsing("editor", function ()
            StackExchange.using("externalEditor", function ()
            StackExchange.using("snippets", function ()
            StackExchange.snippets.init();
            );
            );
            , "code-snippets");

            StackExchange.ready(function()
            var channelOptions =
            tags: "".split(" "),
            id: "1"
            ;
            initTagRenderer("".split(" "), "".split(" "), channelOptions);

            StackExchange.using("externalEditor", function()
            // Have to fire editor after snippets, if snippets enabled
            if (StackExchange.settings.snippets.snippetsEnabled)
            StackExchange.using("snippets", function()
            createEditor();
            );

            else
            createEditor();

            );

            function createEditor()
            StackExchange.prepareEditor(
            heartbeatType: 'answer',
            autoActivateHeartbeat: false,
            convertImagesToLinks: true,
            noModals: true,
            showLowRepImageUploadWarning: true,
            reputationToPostImages: 10,
            bindNavPrevention: true,
            postfix: "",
            imageUploader:
            brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
            contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
            allowUrls: true
            ,
            onDemand: true,
            discardSelector: ".discard-answer"
            ,immediatelyShowMarkdownHelp:true
            );



            );













            draft saved

            draft discarded


















            StackExchange.ready(
            function ()
            StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f53823642%2fhow-to-avoid-nested-foreach-calls%23new-answer', 'question_page');

            );

            Post as a guest















            Required, but never shown

























            3 Answers
            3






            active

            oldest

            votes








            3 Answers
            3






            active

            oldest

            votes









            active

            oldest

            votes






            active

            oldest

            votes









            15














            You should flatten the stream of streams using flatMap instead of map:



            gateways
            .parallelStream()
            .flatMap(gateway -> gateway.getDevices().parallelStream())
            .filter(device -> device.isDisconnected())
            .forEach(device -> device.reconnect());



            I would improve it further by using method references instead of lambda expressions:



            gateways
            .parallelStream()
            .map(Gateway::getDevices)
            .flatMap(List::stream)
            .filter(Device::isDisconnected)
            .forEach(Device::reconnect);





            share|improve this answer






















            • Thank you, it works! Does the code with method references have the same performance as the first one? It looks pretty elegant.
              – Hans van Kessels
              Dec 17 at 22:15






            • 3




              Yes, it does. Please read this post for more detailed explanation.
              – ETO
              Dec 17 at 22:17















            15














            You should flatten the stream of streams using flatMap instead of map:



            gateways
            .parallelStream()
            .flatMap(gateway -> gateway.getDevices().parallelStream())
            .filter(device -> device.isDisconnected())
            .forEach(device -> device.reconnect());



            I would improve it further by using method references instead of lambda expressions:



            gateways
            .parallelStream()
            .map(Gateway::getDevices)
            .flatMap(List::stream)
            .filter(Device::isDisconnected)
            .forEach(Device::reconnect);





            share|improve this answer






















            • Thank you, it works! Does the code with method references have the same performance as the first one? It looks pretty elegant.
              – Hans van Kessels
              Dec 17 at 22:15






            • 3




              Yes, it does. Please read this post for more detailed explanation.
              – ETO
              Dec 17 at 22:17













            15












            15








            15






            You should flatten the stream of streams using flatMap instead of map:



            gateways
            .parallelStream()
            .flatMap(gateway -> gateway.getDevices().parallelStream())
            .filter(device -> device.isDisconnected())
            .forEach(device -> device.reconnect());



            I would improve it further by using method references instead of lambda expressions:



            gateways
            .parallelStream()
            .map(Gateway::getDevices)
            .flatMap(List::stream)
            .filter(Device::isDisconnected)
            .forEach(Device::reconnect);





            share|improve this answer














            You should flatten the stream of streams using flatMap instead of map:



            gateways
            .parallelStream()
            .flatMap(gateway -> gateway.getDevices().parallelStream())
            .filter(device -> device.isDisconnected())
            .forEach(device -> device.reconnect());



            I would improve it further by using method references instead of lambda expressions:



            gateways
            .parallelStream()
            .map(Gateway::getDevices)
            .flatMap(List::stream)
            .filter(Device::isDisconnected)
            .forEach(Device::reconnect);






            share|improve this answer














            share|improve this answer



            share|improve this answer








            edited Dec 18 at 7:35

























            answered Dec 17 at 22:06









            ETO

            1,656321




            1,656321











            • Thank you, it works! Does the code with method references have the same performance as the first one? It looks pretty elegant.
              – Hans van Kessels
              Dec 17 at 22:15






            • 3




              Yes, it does. Please read this post for more detailed explanation.
              – ETO
              Dec 17 at 22:17
















            • Thank you, it works! Does the code with method references have the same performance as the first one? It looks pretty elegant.
              – Hans van Kessels
              Dec 17 at 22:15






            • 3




              Yes, it does. Please read this post for more detailed explanation.
              – ETO
              Dec 17 at 22:17















            Thank you, it works! Does the code with method references have the same performance as the first one? It looks pretty elegant.
            – Hans van Kessels
            Dec 17 at 22:15




            Thank you, it works! Does the code with method references have the same performance as the first one? It looks pretty elegant.
            – Hans van Kessels
            Dec 17 at 22:15




            3




            3




            Yes, it does. Please read this post for more detailed explanation.
            – ETO
            Dec 17 at 22:17




            Yes, it does. Please read this post for more detailed explanation.
            – ETO
            Dec 17 at 22:17













            11














            Don't refactor your code into using Streams. You gain no benefits and gain no advantages over doing it like this, since the code is now less readable and less idiomatic for future maintainers.



            By not using streams, you avoid nested forEach statements.



            Remember: streams are meant to be side-effect free for safer parallelization. forEach by definition introduces side-effects. You lose the benefit of streams and lose readability at the same time, making this less desirable to do at all.






            share|improve this answer






















            • Thanks for your answer. This is just my in-home project. I'm trying to learn Stream API by doing some pseudo-real tasks.
              – Hans van Kessels
              Dec 17 at 22:11







            • 5




              One way to learn about the Stream API is to know when not to apply it. This feels like one of those times, especially since you're not guaranteed that the operations you're performing inside of the stream are side-effect free which would make parallelization safe.
              – Makoto
              Dec 17 at 22:12






            • 8




              I think with ETO's answer above with flatMap, that the stream version is prettier and cleaner than the non-stream version.
              – Mateen Ulhaq
              Dec 18 at 7:40










            • @MateenUlhaq: This isn't about writing "pretty" code. This is about idiomatic code. Streams have the ability to be parallelized. If you use forEach or any terminating operand with side effects, the ability to parallelize your code weakens substantially. If you wanted to do this in parallel, you'd want a different structure to it to ensure that the operation around Device#reconnect was actually thread-safe. Doing it like this doesn't give you that assurance.
              – Makoto
              Dec 18 at 17:18
















            11














            Don't refactor your code into using Streams. You gain no benefits and gain no advantages over doing it like this, since the code is now less readable and less idiomatic for future maintainers.



            By not using streams, you avoid nested forEach statements.



            Remember: streams are meant to be side-effect free for safer parallelization. forEach by definition introduces side-effects. You lose the benefit of streams and lose readability at the same time, making this less desirable to do at all.






            share|improve this answer






















            • Thanks for your answer. This is just my in-home project. I'm trying to learn Stream API by doing some pseudo-real tasks.
              – Hans van Kessels
              Dec 17 at 22:11







            • 5




              One way to learn about the Stream API is to know when not to apply it. This feels like one of those times, especially since you're not guaranteed that the operations you're performing inside of the stream are side-effect free which would make parallelization safe.
              – Makoto
              Dec 17 at 22:12






            • 8




              I think with ETO's answer above with flatMap, that the stream version is prettier and cleaner than the non-stream version.
              – Mateen Ulhaq
              Dec 18 at 7:40










            • @MateenUlhaq: This isn't about writing "pretty" code. This is about idiomatic code. Streams have the ability to be parallelized. If you use forEach or any terminating operand with side effects, the ability to parallelize your code weakens substantially. If you wanted to do this in parallel, you'd want a different structure to it to ensure that the operation around Device#reconnect was actually thread-safe. Doing it like this doesn't give you that assurance.
              – Makoto
              Dec 18 at 17:18














            11












            11








            11






            Don't refactor your code into using Streams. You gain no benefits and gain no advantages over doing it like this, since the code is now less readable and less idiomatic for future maintainers.



            By not using streams, you avoid nested forEach statements.



            Remember: streams are meant to be side-effect free for safer parallelization. forEach by definition introduces side-effects. You lose the benefit of streams and lose readability at the same time, making this less desirable to do at all.






            share|improve this answer














            Don't refactor your code into using Streams. You gain no benefits and gain no advantages over doing it like this, since the code is now less readable and less idiomatic for future maintainers.



            By not using streams, you avoid nested forEach statements.



            Remember: streams are meant to be side-effect free for safer parallelization. forEach by definition introduces side-effects. You lose the benefit of streams and lose readability at the same time, making this less desirable to do at all.







            share|improve this answer














            share|improve this answer



            share|improve this answer








            edited Dec 17 at 22:12

























            answered Dec 17 at 22:08









            Makoto

            80.6k15125173




            80.6k15125173











            • Thanks for your answer. This is just my in-home project. I'm trying to learn Stream API by doing some pseudo-real tasks.
              – Hans van Kessels
              Dec 17 at 22:11







            • 5




              One way to learn about the Stream API is to know when not to apply it. This feels like one of those times, especially since you're not guaranteed that the operations you're performing inside of the stream are side-effect free which would make parallelization safe.
              – Makoto
              Dec 17 at 22:12






            • 8




              I think with ETO's answer above with flatMap, that the stream version is prettier and cleaner than the non-stream version.
              – Mateen Ulhaq
              Dec 18 at 7:40










            • @MateenUlhaq: This isn't about writing "pretty" code. This is about idiomatic code. Streams have the ability to be parallelized. If you use forEach or any terminating operand with side effects, the ability to parallelize your code weakens substantially. If you wanted to do this in parallel, you'd want a different structure to it to ensure that the operation around Device#reconnect was actually thread-safe. Doing it like this doesn't give you that assurance.
              – Makoto
              Dec 18 at 17:18

















            • Thanks for your answer. This is just my in-home project. I'm trying to learn Stream API by doing some pseudo-real tasks.
              – Hans van Kessels
              Dec 17 at 22:11







            • 5




              One way to learn about the Stream API is to know when not to apply it. This feels like one of those times, especially since you're not guaranteed that the operations you're performing inside of the stream are side-effect free which would make parallelization safe.
              – Makoto
              Dec 17 at 22:12






            • 8




              I think with ETO's answer above with flatMap, that the stream version is prettier and cleaner than the non-stream version.
              – Mateen Ulhaq
              Dec 18 at 7:40










            • @MateenUlhaq: This isn't about writing "pretty" code. This is about idiomatic code. Streams have the ability to be parallelized. If you use forEach or any terminating operand with side effects, the ability to parallelize your code weakens substantially. If you wanted to do this in parallel, you'd want a different structure to it to ensure that the operation around Device#reconnect was actually thread-safe. Doing it like this doesn't give you that assurance.
              – Makoto
              Dec 18 at 17:18
















            Thanks for your answer. This is just my in-home project. I'm trying to learn Stream API by doing some pseudo-real tasks.
            – Hans van Kessels
            Dec 17 at 22:11





            Thanks for your answer. This is just my in-home project. I'm trying to learn Stream API by doing some pseudo-real tasks.
            – Hans van Kessels
            Dec 17 at 22:11





            5




            5




            One way to learn about the Stream API is to know when not to apply it. This feels like one of those times, especially since you're not guaranteed that the operations you're performing inside of the stream are side-effect free which would make parallelization safe.
            – Makoto
            Dec 17 at 22:12




            One way to learn about the Stream API is to know when not to apply it. This feels like one of those times, especially since you're not guaranteed that the operations you're performing inside of the stream are side-effect free which would make parallelization safe.
            – Makoto
            Dec 17 at 22:12




            8




            8




            I think with ETO's answer above with flatMap, that the stream version is prettier and cleaner than the non-stream version.
            – Mateen Ulhaq
            Dec 18 at 7:40




            I think with ETO's answer above with flatMap, that the stream version is prettier and cleaner than the non-stream version.
            – Mateen Ulhaq
            Dec 18 at 7:40












            @MateenUlhaq: This isn't about writing "pretty" code. This is about idiomatic code. Streams have the ability to be parallelized. If you use forEach or any terminating operand with side effects, the ability to parallelize your code weakens substantially. If you wanted to do this in parallel, you'd want a different structure to it to ensure that the operation around Device#reconnect was actually thread-safe. Doing it like this doesn't give you that assurance.
            – Makoto
            Dec 18 at 17:18





            @MateenUlhaq: This isn't about writing "pretty" code. This is about idiomatic code. Streams have the ability to be parallelized. If you use forEach or any terminating operand with side effects, the ability to parallelize your code weakens substantially. If you wanted to do this in parallel, you'd want a different structure to it to ensure that the operation around Device#reconnect was actually thread-safe. Doing it like this doesn't give you that assurance.
            – Makoto
            Dec 18 at 17:18












            3














            I would try this with a sequential stream before using a parallel one:



            gateways
            .stream()
            .flatMap(gateway -> gateway.getDevices().stream())
            .filter(device -> device.isDisconnected())
            .forEach(device -> device.reconnect())
            ;


            The idea is to create a stream via gateways.stream() then flatten the sequences returned from gateway.getDevices() via flatMap.



            Then we apply a filter operation which acts like the if statement in your code and finally, a forEach terminal operation enabling us to invoke reconnect on each and every device passing the filter operation.



            see Should I always use a parallel stream when possible?






            share|improve this answer



























              3














              I would try this with a sequential stream before using a parallel one:



              gateways
              .stream()
              .flatMap(gateway -> gateway.getDevices().stream())
              .filter(device -> device.isDisconnected())
              .forEach(device -> device.reconnect())
              ;


              The idea is to create a stream via gateways.stream() then flatten the sequences returned from gateway.getDevices() via flatMap.



              Then we apply a filter operation which acts like the if statement in your code and finally, a forEach terminal operation enabling us to invoke reconnect on each and every device passing the filter operation.



              see Should I always use a parallel stream when possible?






              share|improve this answer

























                3












                3








                3






                I would try this with a sequential stream before using a parallel one:



                gateways
                .stream()
                .flatMap(gateway -> gateway.getDevices().stream())
                .filter(device -> device.isDisconnected())
                .forEach(device -> device.reconnect())
                ;


                The idea is to create a stream via gateways.stream() then flatten the sequences returned from gateway.getDevices() via flatMap.



                Then we apply a filter operation which acts like the if statement in your code and finally, a forEach terminal operation enabling us to invoke reconnect on each and every device passing the filter operation.



                see Should I always use a parallel stream when possible?






                share|improve this answer














                I would try this with a sequential stream before using a parallel one:



                gateways
                .stream()
                .flatMap(gateway -> gateway.getDevices().stream())
                .filter(device -> device.isDisconnected())
                .forEach(device -> device.reconnect())
                ;


                The idea is to create a stream via gateways.stream() then flatten the sequences returned from gateway.getDevices() via flatMap.



                Then we apply a filter operation which acts like the if statement in your code and finally, a forEach terminal operation enabling us to invoke reconnect on each and every device passing the filter operation.



                see Should I always use a parallel stream when possible?







                share|improve this answer














                share|improve this answer



                share|improve this answer








                edited Dec 18 at 5:45









                candied_orange

                4,2571647




                4,2571647










                answered Dec 17 at 22:07









                Aomine

                39.3k73669




                39.3k73669



























                    draft saved

                    draft discarded
















































                    Thanks for contributing an answer to Stack Overflow!


                    • Please be sure to answer the question. Provide details and share your research!

                    But avoid


                    • Asking for help, clarification, or responding to other answers.

                    • Making statements based on opinion; back them up with references or personal experience.

                    To learn more, see our tips on writing great answers.





                    Some of your past answers have not been well-received, and you're in danger of being blocked from answering.


                    Please pay close attention to the following guidance:


                    • Please be sure to answer the question. Provide details and share your research!

                    But avoid


                    • Asking for help, clarification, or responding to other answers.

                    • Making statements based on opinion; back them up with references or personal experience.

                    To learn more, see our tips on writing great answers.




                    draft saved


                    draft discarded














                    StackExchange.ready(
                    function ()
                    StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f53823642%2fhow-to-avoid-nested-foreach-calls%23new-answer', 'question_page');

                    );

                    Post as a guest















                    Required, but never shown





















































                    Required, but never shown














                    Required, but never shown












                    Required, but never shown







                    Required, but never shown

































                    Required, but never shown














                    Required, but never shown












                    Required, but never shown







                    Required, but never shown






                    Popular posts from this blog

                    How to check contact read email or not when send email to Individual?

                    Displaying single band from multi-band raster using QGIS

                    How many registers does an x86_64 CPU actually have?