Effective Java

---

CHAPTER 7
LAMBDAS AND STREAMS
210
Item 46: Prefer side-effect-free functions in streams 
If you’re new to streams, it can be difficult to get the hang of them. Merely
expressing your computation as a stream pipeline can be hard. When you succeed,
your program will run, but you may realize little if any benefit. Streams isn’t just
an API, it’s a paradigm based on functional programming. In order to obtain the
expressiveness, speed, and in some cases parallelizability that streams have to
offer, you have to adopt the paradigm as well as the API.
The most important part of the streams paradigm is to structure your compu-
tation as a sequence of transformations where the result of each stage is as close as
possible to a 
pure function
of the result of the previous stage. A pure function is
one whose result depends only on its input: it does not depend on any mutable
state, nor does it update any state. In order to achieve this, any function objects
that you pass into stream operations, both intermediate and terminal, should be
free of side-effects.
Occasionally, you may see streams code that looks like this snippet, which
builds a frequency table of the words in a text file:
// Uses the streams API but not the paradigm--Don't do this!
Map freq = new HashMap<>();
try (Stream words = new Scanner(file).tokens()) {
words.forEach(word -> {
freq.merge(word.toLowerCase(), 1L, Long::sum);
});
}
What’s wrong with this code? After all, it uses streams, lambdas, and method
references, and gets the right answer. Simply put, it’s not streams code at all; it’s
iterative code masquerading as streams code. It derives no benefits from the
streams API, and it’s (a bit) longer, harder to read, and less maintainable than the
corresponding iterative code. The problem stems from the fact that this code is
doing all its work in a terminal 
forEach
operation, using a lambda that mutates
external state (the frequency table). A 
forEach
operation that does anything more
than present the result of the computation performed by a stream is a “bad smell in
code,” as is a lambda that mutates state. So how should this code look?