Processing Data Using Streams and Lambda Expressions practice questions

IntStream.range(start, end) excludes end; IntStream.rangeClosed(start, end) includes it.

Both factory methods produce ascending int streams starting at the first argument. range stops before the second argument, matching the familiar for (int i = start; i < end; i++) loop, so range(1, 4) is 1, 2, 3 with sum 6. rangeClosed stops at the second argument, so rangeClosed(1, 4) is 1, 2, 3, 4 with sum 10. sum() on an IntStream returns an int, so both assignments compile.

1. Expand rangeClosed(1, 4): 1, 2, 3, 4.
2. Expand range(1, 4): 1, 2, 3.
3. Sum each stream: 10 and 6.
4. Print a then b.

Exam tip: range is half-open like a for loop; rangeClosed includes both ends.

Each core functional interface has one abstract method with a fixed name and shape: Predicate.test, Function.apply, Supplier.get, Consumer.accept.

The call check.test("java") needs a type whose abstract method is test taking a String, which is Predicate<String>. Every Predicate declaration compiles, but only the ones whose logic is true for java print long word: the length check and the contains check. Function<String, Boolean> has the right shape but calls its method apply, and Supplier takes no argument. The isBlank reference is a valid Predicate that returns false, so nothing is printed.

1. Identify the method the code calls: test with one String argument.
2. Match it to Predicate<String>; Function uses apply and Supplier uses get.
3. For each Predicate, evaluate it on java.
4. Keep the two that both compile and return true, so the if body runs.

Exam tip: Know the method names: Predicate test, Function apply, Supplier get, Consumer accept.

map transforms each element into a new value (possibly a new type); later operations see only the transformed values.

After map(s -> s.length()) the stream is a Stream<Integer> holding 1, 2, 3 and 4; the original strings are gone. filter keeps the elements for which n % 2 == 1 is true, which are 1 and 3. forEach(System.out::print) prints them back to back, giving 13. The accc answer forgets that map replaced the strings; 24 inverts the predicate.

1. Apply map: a, bb, ccc, dddd become 1, 2, 3, 4.
2. Apply filter: keep values with remainder 1, so 1 and 3.
3. Print each kept value with no separator.
4. Result: 13.

Exam tip: After map, the pipeline works on the mapped values, not the originals.

Stream elements flow through the pipeline one at a time, and short-circuiting terminal operations such as findFirst stop pulling elements once they have a result.

A sequential stream does not run filter over the whole source and then map over the survivors. It pulls one element, sends it through filter and, if it passes, through map to findFirst, then pulls the next. one (f3) and two (f3) are rejected. three (f5) passes, map prints m and returns THREE, and findFirst has its answer, so the stream stops and four is never filtered. ifPresent then prints THREE. Both tempting answers include f4 because they assume every element is filtered.

1. Trace one: filter prints f3 and rejects it.
2. Trace two the same way: f3, rejected.
3. Trace three: f5, accepted, map prints m, findFirst receives THREE.
4. Note that findFirst short-circuits, so four is never pulled.
5. ifPresent prints THREE.

Exam tip: Trace streams element by element, and stop at the first result for findFirst, anyMatch and limit.

A Stream can be traversed only once; any second operation on the same stream object throws IllegalStateException.

stream.filter(...) links a new stage to stream, and count() consumes the pipeline, so n is 2 and "2 " is printed. The next line calls forEach on the same stream object, which is already linked and consumed. The JDK throws IllegalStateException with the message stream has already been operated upon or closed. The compiler cannot see this, so the code compiles; the answers 2 123 and 2 23 assume the stream can be replayed like the list it came from.

1. Evaluate the first pipeline: 2 and 3 pass the filter, count returns 2.
2. Print "2 ".
3. Notice that forEach is called on the same Stream object already used by filter.
4. A reused stream throws IllegalStateException at run time.

Exam tip: Streams are single-use: create a new one from the source (list.stream()) for every pipeline.

A stream can have only one downstream operation, and the check happens when an operation is linked, not when a terminal operation runs.

Calling base.filter(...) for evens marks base as linked. evens is never consumed, but that does not matter: the second call base.filter(...) checks the source stage, finds it already linked, and throws IllegalStateException (stream has already been operated upon or closed) at that line. So A is printed, the exception is thrown, and B never appears. The tempting answer that prints B first combines laziness (true for element processing) with the reuse rule (which is checked eagerly).

1. Run the first filter: base is now linked to a downstream stage.
2. Print "A ".
3. Run the second filter on base: the stage is already linked, so it throws immediately.
4. No later line runs, so B and the elements are never printed.

Exam tip: Element processing is lazy, but stream reuse is detected eagerly, at the second operation call.