72

I'm reading from the java 8 API on the stream abstraction but I don't understand this sentence very well:

Intermediate operations return a new stream. They are always lazy; executing an intermediate operation such as filter() does not actually perform any filtering, but instead creates a new stream that, when traversed, contains the elements of the initial stream that match the given predicate. Traversal of the pipeline source does not begin until the terminal operation of the pipeline is executed.

When a filter operation creates a new stream does that stream contain a filtered element? It seems to understand that the stream contains elements only when it is traversed i.e with a terminal operation. But, then, what does the filtered stream contain? I'm confused!!!

Improve this question
2
  • 1
    @Lukas, we already have java-stream for the Java 8 Stream API. The tag you created is very ... generic. Commented Jan 22, 2014 at 21:37
  • 16
    But its official name is "Streams API", not "Java-Stream". Java Stream can mean anything. Including InputStream / OutputStream and the likes. Anyway, I guess this should be taken to meta... Commented Jan 23, 2014 at 8:02

3 Answers 3

Reset to default
91

It means that the filter is only applied during the terminal operation. Think of something like this:

public Stream filter(Predicate p) { this.filter = p; // just store it, don't apply it yet return this; // in reality: return a new stream } public List collect() { for (Object o : stream) { if (filter.test(o)) list.add(o); } return list; }

(That does not compile and is a simplification of the reality but the principle is there)

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

41

Streams are lazy because intermediate operations are not evaluated unless terminal operation is invoked.

Each intermediate operation creates a new stream, stores the provided operation/function and return the new stream.

The pipeline accumulates these newly created streams.

The time when terminal operation is called, traversal of streams begins and the associated function is performed one by one.

Parallel streams don't evaluate streams 'one by one' (at terminal point). The operations are rather performed simultaneously, depending on the available cores.

Improve this answer

Comments

0

It seems to me, that intermediate operation not exactly lazy:

List<String> l3 = new ArrayList<String>(); l3.add("first"); l3.add("second"); l3.add("third"); l3.add("fouth"); l3.add("fith"); l3.add("sixth"); List<String> test3 = new ArrayList<String>(); try { l3.stream().filter(s -> { l3.clear(); test3.add(s); return true;}).forEach(System.out::println); } catch (Exception ex) { ex.printStackTrace(); System.out.println("!!! "); System.out.println(test3.stream().reduce((s1, s2) -> s1 += " ;" + s2).get()); }

Otput:

 first null null null null null java.util.ConcurrentModificationException at java.util.ArrayList$ArrayListSpliterator.forEachRemaining(ArrayList.java:1380) at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:481) at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:471) at java.util.stream.ForEachOps$ForEachOp.evaluateSequential(ForEachOps.java:151) at java.util.stream.ForEachOps$ForEachOp$OfRef.evaluateSequential(ForEachOps.java:174) at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234) at java.util.stream.ReferencePipeline.forEach(ReferencePipeline.java:418) at test.TestParallel.main(TestParallel.java:69) !!! first ;null ;null ;null ;null ;null

Looks like number of iteration sets on stream creation, but geting a new stream element lazy.

Compare to loop with counter:

public static void main(String[] args) { List<Integer> list = new ArrayList<>(); list.add(1); list.add(2); list.add(3); list.add(4); list.add(5); int i = 0; while (i < list.size()) { System.out.println(list.get(i++)); list.clear(); } }

Output:

1

Only one expected iteration. I agree that problem in Exception throwing behavior in streams, but i think lazy means get data (or perform some action) only when i ask some object to do it; and count of data is also data.

Improve this answer

5 Comments

Could you please format your code by highlighting it and hitting Ctrl+K
Just because it iterates 6 times does not mean it is not lazy. Look at the code for ArrayList line 1380 (forEachRemaining) What happened is that it doesn't throw ConcurrentModificationExcception until it has iterated over the whole list. forEachRemaining is a "terminal operation".
"doesn't throw ConcurrentModificationExcception until it has iterated over the whole list." I think - throwing ConcurrentModificationExcception only after iterated "whole list" (after list.clear() - whole list is empty list) - is not lazy behavior. If i do the same with iterator - i will see only one output before ConcurrentModificationExcception;
Well, this whole example is barely related to laziness, at least laziness in the context of Java Streams. If an intermediate operation was not lazy, calling filter only would already traverse the elements. And it doesn't, so intermediate operations on streams are lazy.
I found this definition - "Lazy evaluation means delaying a computation until the result is needed" link. In this example - when result is needed - needed 2 elements, but i got 1: int[] a = {2}; IntStream.range(0, 10).limit(--a[0]).peek(System.out::println).limit(++a[0]).forEach(i -> {}); What meaning do you think has the "laziness in the context of Java Stream"?

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.