for (Canvas canvas : list) {

NetBeans suggests me to use "functional operations":

list.stream().forEach((canvas) -> {

But why is this preferred? If anything, it is harder to read and understand. You are calling stream(), then forEach() using a lambda expression with parameter canvas. I don't see how is that any nicer than the for loop in the first snippet.

Obviously I am speaking out of aesthetics only. Perhaps there is a technical advantage here that I am missing. What is it? Why should I use the second method instead?

  • 3
    – gnat
    Commented Sep 13, 2015 at 19:18
  • 18
    In your particular example, it would not be preferred. Commented Sep 13, 2015 at 20:42
  • 1
    As long as the only operation is a single forEach, I tend to agree with you. As soon as you add other operations to the pipeline, or you produce an output sequence, then the stream-approach becomes preferable.
    – JacquesB
    Commented Dec 1, 2015 at 21:56
  • @RobertHarvey wouldn't it? why not?
    – sara
    Commented Jun 22, 2016 at 18:07
  • 1
    @kai: Counter-question: would you use the Netbeans version exclusively, just because Netbeans says so? Why or why not? In the OP's example, he doesn't use Stream's features, so there's no compelling reason to use Netbeans' version. If you don't need the advanced features, simpler and clearer always wins. Commented Jun 22, 2016 at 18:19

4 Answers 4


Streams provide much better abstraction for composition of different operations you want to do on top of collections or streams of data coming in. Especially when you need to map elements, filter and convert them.

Your example is not very practical. Consider the following code from Oracle's site.

List<Transaction> groceryTransactions = new Arraylist<>();
for(Transaction t: transactions){
    if(t.getType() == Transaction.GROCERY){
Collections.sort(groceryTransactions, new Comparator(){
    public int compare(Transaction t1, Transaction t2){
        return t2.getValue().compareTo(t1.getValue());
List<Integer> transactionIds = new ArrayList<>();
for(Transaction t: groceryTransactions){

can be written using streams:

List<Integer> transactionsIds = 
                .filter(t -> t.getType() == Transaction.GROCERY)

The second option is much more readable. So when you have nested loops or various loops doing partial processing, it's very good candidate for Streams/Lambda API usage.

  • 8
    There are optimization techniques like map fusion (stream.map(f).map(g)stream.map(f.andThen(g))) build/reduce fusion (when building a stream in one method and then passing it to another method which consumes it, the compiler can eliminate the stream) and stream fusion (which can fuse many stream ops together into a single imperative loop), which can make stream operations much more efficient. They are implemented in the GHC Haskell compiler, and also in some other Haskell and other functional language compilers, and there are experimental research implementations for Scala. Commented Sep 14, 2015 at 3:05
  • Performance probably isn't a factor when considering functional vs loop as surely the compiler could/should do the conversion from a for loop to a functional operation if Netbeans can and it is determined to be the optimal path.
    – Ryan
    Commented Apr 11, 2017 at 18:12
  • 1
    I would disagree that the second is more readable. It takes a while to figure out what's going on. Is there a performance advantage to doing it the second method because otherwise I don't see it? Commented Jan 18, 2019 at 3:07
  • 3
    @BokMcDonagh, Me experience is that it is less readable for developers that didn't bother to get familiar with new abstractions. I would suggest to more use such APIs, to get more familiar, because it is the future. Not only in Java world.
    – luboskrnac
    Commented Jan 18, 2019 at 8:13

Another advantage of using the functional streaming API is, that it hides implementation details. It only describes what should be done, not how. This advantage becomes obvious when looking at the change that needs to be done, to change from single threaded to parallel code execution. Just change the .stream() to .parallelStream().


If anything, it is harder to read and understand.

That is highly subjective. I find the second version much easier to read and understand. It matches how other languages (e.g. Ruby, Smalltalk, Clojure, Io, Ioke, Seph) do it, it requires fewer concepts to understand (it's just a normal method call like any other, whereas the first example is specialized syntax).

If anything, it's a matter of familiarity.

  • 8
    Yeah that's true. But this looks more like a comment than an answer to me.
    – Saturn
    Commented Sep 14, 2015 at 3:25
  • 1
    The funtional operation uses specialized syntax too: the "->" is new
    – Ryan
    Commented Apr 11, 2017 at 18:14

Personally, More abstration = harder to program. So i will go with the first and truly lamda is the worst that programmers created. it just complicates things. Clearly it is usefull in some cases but, it is far less readable and i take about 3 times more to be able to understand it. I think they make it to "look cool" May be mistaken but i truly doubt it has any real application. (excpet to pretend you are better)

  • Do you do all your programming by writing the bytes for the executable directly, or do you in fact use a higher level more abstract programming language and tools? Commented Sep 30, 2021 at 14:01
  • Your answer could be improved with additional supporting information. Please edit to add further details, such as citations or documentation, so that others can confirm that your answer is correct. You can find more information on how to write good answers in the help center.
    – Community Bot
    Commented Sep 30, 2021 at 14:50
  • If abstraction made programming harder we would all be programming in machine language so I think there is a bit more nuance. Java itself is abstraction of a “virtual machine” which executes byte code which is itself an abstraction of the real machine’s instruction set. However it’s true that code can become pretty obfuscated by badly designed abstractions. Hence the common derision of java libraries for having so many classes that you can’t make heads or tails of. What does a SemanticEntityManagerBean do? Anything I have a lot of experience with is “easier” than things I don’t use very much.
    – Logachu
    Commented Feb 25 at 20:00

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.