1Z0-829 Working with Streams and Lambda Expressions Practice Test 4 — 15 Questions

Question 1

Assuming the code runs in a multithreaded environment, which statement best describes the behavior?

Accepted Answer

It prints the doubled numbers in a non-deterministic order and results may contain missing or duplicate entries.. Using a parallel stream with a stateful lambda (e.g., modifying an external `results` list inside `peek` or `forEach`) introduces data races and non-deterministic behavior. The `peek` operation is not synchronized, so the order of printed doubled numbers is unpredictable, and concurrent modifications to the shared `results` list can cause missing or duplicate entries due to race conditions.

Answer

The code will compile but throw an exception at runtime because of the use of parallel stream with stateful lambda.

Answer

It prints the doubled numbers in order (2, 4, 6, 8) and results contains [1,2,3,4] in that order.

Answer

It may produce a ConcurrentModificationException because results is modified while iterating.

Question 2

A developer needs to concatenate two Stream<String> into one. Which approach is most idiomatic?

Accepted Answer

Stream.concat(stream1, stream2). `Stream.concat(stream1, stream2)` is the idiomatic, built-in static method in the Java Stream API for concatenating two streams into a single sequential stream. It creates a lazily concatenated stream whose elements are all the elements of the first stream followed by all the elements of the second stream, preserving encounter order.

Answer

stream1.flatMap(s -> stream2)

Answer

new StreamBuilder().add(stream1).add(stream2).build()

Answer

stream1.merge(stream2)

Question 3

A developer wants to collect elements from a stream into an immutable List. Which collector should be used?

Accepted Answer

Collectors.toUnmodifiableList(). `Collectors.toUnmodifiableList()` directly returns a collector that accumulates elements into an immutable `List`. This was introduced in Java 10 and guarantees that the resulting list cannot be modified, throwing `UnsupportedOperationException` on any mutation attempt.

Answer

Collectors.toList()

Answer

Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)

Answer

Collectors.toList().stream().collect(Collectors.toUnmodifiableList())

Question 4

A stream pipeline uses the peek method for debugging. Which statement about peek is correct?

Accepted Answer

peek is an intermediate operation used for debugging; it is not suitable for production side effects.. The `peek` method is an intermediate operation in the Stream API, designed primarily for debugging to observe elements as they flow through the pipeline. It is not intended for production side effects because its execution is not guaranteed for every element (e.g., due to short-circuiting or optimization), and relying on it for stateful operations can lead to unpredictable behavior.

Answer

peek is a terminal operation that prints elements.

Answer

peek can only be used with parallel streams.

Answer

peek is an intermediate operation, and it is guaranteed to be executed for each element.

Question 5

A method receives a List<String> and needs to transform it to a Map where the key is the first three characters of each string and the value is the string itself. If two strings have the same prefix, the later one should override the earlier. Which collector achieves this?

Accepted Answer

Collectors.toMap(s -> s.substring(0,3), Function.identity(), (a,b) -> b). `Collectors.toMap` with a merge function `(a, b) -> b` ensures that when duplicate keys (first three characters) occur, the later string in the stream order replaces the earlier one. The merge function is invoked on key collision, and returning `b` (the second argument) keeps the later value, satisfying the requirement.

Answer

Collectors.groupingBy(s -> s.substring(0,3))

Answer

Collectors.toMap(s -> s.substring(0,3), Function.identity())

Answer

Collectors.toConcurrentMap(s -> s.substring(0,3), Function.identity())

Question 6

A stream pipeline uses sorted() with a Comparator that calls a thread-unsafe method on each element. The pipeline is parallel. What is the likely outcome?

Accepted Answer

The pipeline may produce incorrect ordering or throw a ConcurrentModificationException.. In a parallel stream pipeline, the `sorted()` operation requires a stable sort that merges results from multiple threads. If the provided `Comparator` calls a thread-unsafe method on each element, concurrent invocations from different threads can cause race conditions, leading to incorrect ordering or a `ConcurrentModificationException` if the method modifies shared state. The pipeline does not automatically fall back to sequential execution for `sorted()` when the comparator is stateful or unsafe.

Answer

The pipeline will throw an exception because the comparator is stateful.

Answer

The pipeline will sort correctly because sorted() is a sequential operation.

Answer

The pipeline will run sequentially because the stream source is not ordered.

Question 7

A lambda expression that takes two integers and returns a boolean indicating whether the first is greater than the second is best represented by which functional interface?

Accepted Answer

BiPredicate. BiPredicate is a functional interface that takes two arguments (both Integer) and returns a boolean, which exactly matches the lambda expression's signature (int, int) -> boolean. The lambda can be written as (a, b) -> a > b, and BiPredicate is the standard interface for such two-argument boolean-valued operations.

Answer

BiFunction<Integer, Integer, Boolean>

Answer

Predicate<Integer>

Answer

BinaryOperator<Boolean>

Question 8

A developer uses a parallel stream to process a large collection and wants to collect results into a List while preserving encounter order. Which of the following collectors will guarantee order preservation?

Accepted Answer

collect(ArrayList::new, List::add, List::addAll). The custom collector using `ArrayList::new`, `List::add`, and `List::addAll` explicitly specifies an insertion-ordered collection (`ArrayList`) and uses the combiner `List::addAll`, which preserves the encounter order when merging partial results from parallel streams. The `Collectors.toList()` and `Collectors.toUnmodifiableList()` do not guarantee order preservation in parallel streams, as their internal implementations may use non-ordered structures like `HashSet` during accumulation.

Answer

collect(Collectors.toUnmodifiableList())

Answer

collect(Collectors.toList())

Answer

collect(Collectors.toMap(Function.identity(), v->v))

Answer

collect(Collectors.toCollection(TreeSet::new))

Question 9

A stream pipeline filters strings, sorts them, and returns the first match: .filter(s -> s.length() > 3).sorted().findFirst(). This is inefficient because sorted() processes all elements. Which alternative achieves the same result with better performance?

Accepted Answer

.filter(s -> s.length() > 3).min(Comparator.naturalOrder()). `min(Comparator.naturalOrder())` is a terminal operation that finds the smallest element according to natural ordering without sorting the entire stream. It uses a single pass reduction, which is O(n) in time complexity, whereas `sorted().findFirst()` must sort all elements (O(n log n)) before picking the first. This makes `min()` significantly more efficient for this use case.

Answer

.filter(s -> s.length() > 3).sorted().limit(1).findFirst()

Answer

.filter(s -> s.length() > 3).parallel().sorted().findFirst()

Answer

.filter(s -> s.length() > 3).sorted().collect(Collectors.toList()).get(0)

Question 10

A lambda that takes a String and returns its length is assigned to which functional interface?

Accepted Answer

Function. The lambda `(String s) -> s.length()` takes a `String` input and returns an `Integer` (the length). This matches the `Function` functional interface, which defines the abstract method `R apply(T t)`. Option E is correct because `Function` exactly represents a function that accepts a `String` and produces an `Integer`.

Answer

UnaryOperator<String>

Answer

Consumer<String>

Answer

Predicate<String>

Answer

Supplier<Integer>

Question 11

A developer uses a stateful lambda in a parallel stream. Which of the following is a potential consequence?

Accepted Answer

Non-deterministic results. Stateful lambdas (e.g., those that modify shared mutable state) in parallel streams break the non-interference and statelessness requirements of the Stream API. Because parallel streams split the source into substreams processed by multiple threads, the lack of synchronization leads to race conditions, producing non-deterministic results that vary between runs.

Answer

ConcurrentModificationException

Answer

All of the above

Answer

Improved performance

Question 12

Given a list of strings, which of the following will produce a Map<String, Long> counting the occurrences of each string?

Accepted Answer

.collect(Collectors.groupingBy(Function.identity(), Collectors.counting())). `Collectors.groupingBy(Function.identity(), Collectors.counting())` groups each string by itself (using `Function.identity()` as the classifier) and then applies a downstream collector `Collectors.counting()` that counts the number of elements in each group, producing a `Map<String, Long>` where each key is a unique string and the value is its frequency.

Answer

.collect(Collectors.toMap(Function.identity(), String::length))

Answer

.collect(Collectors.groupingBy(Function.identity(), Collectors.summingInt(e->1)))

Answer

.collect(Collectors.toMap(Function.identity(), v->1))

Question 13

Which of the following is a terminal operation of the Stream API?

Accepted Answer

forEach(). (forEach()) is correct because it is a terminal operation in the Stream API. Terminal operations produce a result or side effect and close the stream, meaning no further operations can be performed on the same stream. forEach() consumes each element of the stream and returns void, making it a terminal operation.

Answer

map()

Answer

filter()

Answer

peek()

Question 14

A developer adds .peek(System.out::println) to a stream pipeline to debug, but no output is printed. What is the most likely reason?

Accepted Answer

The pipeline lacks a terminal operation. Stream pipelines are lazy; intermediate operations like peek() are only executed when a terminal operation (e.g., forEach, collect, reduce) is invoked. Without a terminal operation, the pipeline never starts processing data, so peek() produces no output.

Answer

The stream is parallel

Answer

The peek operation is placed after the terminal operation

Answer

The stream is empty

Question 15

Which of the following lambda expressions is syntactically invalid?

Accepted Answer

(a, b) -> return a + b;. Syntactically invalid because in a lambda expression, the `return` keyword is only allowed inside a block body (with braces). When using an expression body (no braces), the `return` keyword must be omitted, and the expression itself is implicitly returned. Option C incorrectly uses `return` without braces, which is a syntax error.

Answer

() -> {return 42;}

Answer

(a, b) -> a + b

Answer

(int a, int b) -> a + b

Answer

(a) -> a * 2