38
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
  • 15
    In your particular example, it would not be preferred. – Robert Harvey Sep 13 '15 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 Dec 1 '15 at 21:56
  • @RobertHarvey wouldn't it? why not? – sara Jun 22 '16 at 18:07
  • @RobertHarvey well I agree the accepted answer really shows how the for-version gets blown out of the water for more complicated cases, but I don't see why for "wins" in the trivial case. you state it like it's self-evident but I don't see it, so I asked. – sara Jun 22 '16 at 18:13
45

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 site.

List<Transaction> groceryTransactions = new Arraylist<>();
for(Transaction t: transactions){
  if(t.getType() == Transaction.GROCERY){
    groceryTransactions.add(t);
  }
}
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){
  transactionsIds.add(t.getId());
}

can be written using streams:

List<Integer> transactionsIds = 
    transactions.stream()
                .filter(t -> t.getType() == Transaction.GROCERY)
                .sorted(comparing(Transaction::getValue).reversed())
                .map(Transaction::getId)
                .collect(toList());

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.

  • 5
    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. – Jörg W Mittag Sep 14 '15 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 Apr 11 '17 at 18:12
  • 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? – Bok McDonagh Jan 18 at 3:07
  • @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 Jan 18 at 8:13
16

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().

13

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.

  • 5
    Yeah that's true. But this looks more like a comment than an answer to me. – Omega Sep 14 '15 at 3:25
  • The funtional operation uses specialized syntax too: the "->" is new – Ryan Apr 11 '17 at 18:14

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

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