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

Question 1

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?

Choose an answer to begin — your selection is scored in the full session.

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 2

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 3

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 4

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 5

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 6

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 7

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 8

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

Question 9

Which TWO of the following are characteristics of a well-designed lambda expression? (Choose two.)

Accepted Answer

Is stateless. Option A is correct because a well-designed lambda should be stateless: it must not rely on or mutate shared mutable state, so it can be executed safely in parallel streams and reused without side effects. Option D is correct because lambdas may only capture variables from the enclosing scope that are final or effectively final (assigned once), which prevents unsafe mutation of captured locals and keeps the lambda's behavior predictable. Option B is wrong because a lambda body cannot throw checked exceptions that are not declared by the functional interface's abstract method; only unchecked exceptions are allowed freely. Option C is wrong because a lambda parameter name may not shadow a local variable of the enclosing method, which is a compile-time error. Option E is wrong because modifying an enclosing method's local variable inside a lambda is illegal since captured locals must be effectively final.

Answer

Throws exceptions that are not declared in the functional interface's abstract method

Answer

Uses the same variable name as a parameter in the enclosing scope (shadowing)

Answer

Modifies local variables of the enclosing method

Question 10

Which THREE of the following are valid ways to create a Stream<String>? (Choose three.)

Accepted Answer

Arrays.stream(new String[]{"a", "b"}). Option A is correct because Arrays.stream(T[] array) is a static factory method on java.util.Arrays that accepts an object array such as new String[]{"a", "b"} and returns a Stream whose elements are the array's elements. Option B is correct because Stream.of(T... values) is a static factory method on java.util.stream.Stream that takes a varargs of String values ("a", "b") and returns a Stream. Option C is correct because List.of("a", "b") creates an immutable List, and calling stream() on any Collection (including List) returns a Stream of its elements. Option D is not correct because "ab".chars() returns an IntStream of primitive int character values, not a Stream. Option E is not correct because Stream is an interface and cannot be instantiated with new Stream(); streams must be obtained via factory methods or from a source such as a collection or array.

Answer

"ab".chars()

Answer

new Stream<String>()

Question 11

Which THREE of the following are true about the Optional class? (Choose three.)

Accepted Answer

Optional.empty().orElseThrow(IllegalStateException::new) throws IllegalStateException. Option A is correct: Optional.empty() creates an empty Optional, and orElseThrow(IllegalStateException::new) invokes the supplied exception supplier when no value is present, so it throws a new IllegalStateException. Option C is correct: Optional.ofNullable(null) explicitly returns an empty Optional because ofNullable is designed to accept null and map it to Optional.empty(). Option E is correct: ifPresent executes the given Consumer only when a value is present, so on an empty Optional the lambda is skipped and nothing is printed. Option B is wrong because Optional.of(null) throws NullPointerException rather than returning an empty Optional. Option D is wrong because Optional.get() on an empty Optional throws NoSuchElementException, not null.

Answer

Optional.of(null) returns an empty Optional

Answer

Optional.get() on empty Optional returns null

Question 12

A developer wants to compute the product of all even numbers in a stream of integers. Which of the following correctly implements this using streams?

Accepted Answer

filter(n -> n % 2 == 0).reduce(1, (a, b) -> a * b). It first filters the stream to keep only even numbers (n % 2 == 0), then uses reduce with an identity of 1 and a multiplication lambda (a, b) -> a * b. The identity 1 is the neutral element for multiplication, ensuring that if no even numbers exist, the result is 1 rather than an error or incorrect value.

Answer

reduce(1, (a, b) -> (a % 2 == 0) ? a * b : a)

Answer

filter(n -> n % 2 == 0).reduce(0, (a, b) -> a * b)

Answer

reduce(1, (a, b) -> a * b)

Question 13

A Java team is processing a large dataset with parallel streams. They notice inconsistent results due to non-atomic operations on shared mutable state. Which approach should they use to ensure thread-safety while maximizing performance?

Accepted Answer

Use the collect method with a concurrent Collector such as toConcurrentMap().. The `collect` method with a concurrent `Collector` like `toConcurrentMap()` ensures thread-safe accumulation by leveraging `ConcurrentHashMap` internally, which uses fine-grained locking or lock-free operations. This approach allows multiple threads to update the shared mutable state concurrently without external synchronization, maximizing parallelism and performance while maintaining consistency.

Answer

Use forEach with AtomicInteger and update atomically.

Answer

Use synchronized blocks inside the lambda expression.

Answer

Use ConcurrentHashMap for accumulation, but collect using toList().

Question 14

A developer writes the following code to print a list of strings in order: list.stream().map(s -> s.toUpperCase()).forEach(System.out::print). They want to parallelize the processing but must preserve the output order. Which change is correct and most appropriate?

Accepted Answer

list.parallelStream().map(s -> s.toUpperCase()).forEachOrdered(System.out::print);. `forEachOrdered` guarantees that elements are processed in encounter order even when the stream is parallelized. The `map` operation is stateless and can run in parallel, but the terminal operation must preserve order, which `forEachOrdered` does by enforcing sequential output in the stream's encounter order.

Answer

list.parallelStream().map(s -> s.toUpperCase()).forEach(System.out::print);

Answer

list.stream().parallel().map(s -> { synchronized(System.out) { return s.toUpperCase(); } }).forEach(System.out::print);

Answer

list.stream().parallel().map(s -> s.toUpperCase()).sequential().forEach(System.out::print);

Question 15

Which two statements are true about the peek method of the Stream API? (Choose two.)

Accepted Answer

It is primarily used for debugging purposes.. Option A is correct because Stream.peek(Consumer) is designed mainly for debugging: it lets you inspect elements as they flow through the pipeline without altering the stream's result. Option B is correct because peek is an intermediate operation that returns a new Stream, so it is lazy and only executes when a terminal operation is invoked. Option C is not correct because peek's Consumer should not mutate stream elements; doing so is discouraged and can produce unpredictable results. Option D is not correct because peek is not a terminal operation—it does not trigger pipeline execution by itself. Option E is not correct because peek does not transform elements into new values; that is the role of map.

Answer

It can be used to modify the elements of the stream.

Answer

It is a terminal operation.

Answer

It can be used to transform the elements into a new value.