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

Question 1

A developer is using a parallel stream to compute a running total of integers from a large list. The code uses `reduce` with an identity and an accumulator, but the result varies between runs. Which two changes will make the computation deterministic and correct? (Choose two.)

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

Accepted Answer

Ensure the accumulator function is associative and the identity value is a true identity for the operation.. Parallel reduction demands an associative accumulator and a genuine identity value, and when using an identity-based reduce in parallel, a combiner is essential to merge partial results. Together these ensure that thread scheduling does not affect the outcome. Synchronization, post-terminal parallel calls, and collecting to a list do not address the mathematical requirements of parallel reduction, so they cannot guarantee deterministic results.

Answer

Replace the stream with a `Collectors.toList()` collector and sum the list afterward.

Answer

Call `parallel()` after the terminal operation to force consistent ordering.

Answer

Use a synchronized block inside the accumulator to guard the running total variable.

Question 2

A developer wants to create a stream of integers from 1 to 10 inclusive and print each doubled value. Which code snippet accomplishes this using the IntStream API?

Accepted Answer

IntStream.rangeClosed(1, 10).map(n -> n * 2).forEach(System.out::println);. IntStream.rangeClosed(1, 10) produces exactly the integers 1 through 10 inclusive. Mapping each to double its value and printing with forEach satisfies the requirement. The exclusive range variant omits 10, the forEach-only variant skips mapping, and the iterate variant is an indirect way to generate the same numbers but does not use the range method that directly expresses inclusive bounds.

Answer

IntStream.iterate(1, n -> n + 1).limit(10).map(n -> n * 2).forEach(System.out::println);

Answer

IntStream.rangeClosed(1, 10).forEach(n -> System.out.println(n * 2));

Answer

IntStream.range(1, 10).map(n -> n * 2).forEach(System.out::println);

Question 3

A developer writes the following code using the Stream API:

List<String> list = List.of("a", "b", "c");
String result = list.stream().reduce("", (s1, s2) -> s1 + s2);
System.out.println(result);

What is the output?

Accepted Answer

abc. The `reduce` method with an identity value (`""`) and a binary operator (`(s1, s2) -> s1 + s2`) accumulates the stream elements in encounter order. Starting from the identity, it concatenates each element: `"" + "a" = "a"`, then `"a" + "b" = "ab"`, then `"ab" + "c" = "abc"`. The result is a `String`, not an `Optional`, because an identity is provided.

Answer

a

Answer

Optional[abc]

Answer

cba

Question 4

A developer writes: List list = List.of(1, 2, 3); Optional opt = list.stream().reduce((a, b) -> a + b); System.out.println(opt.get()); What is the result?

Accepted Answer

6. The `reduce` method with a single argument (a `BinaryOperator`) returns an `Optional` because the stream might be empty. Here, the stream contains three integers, so the reduction computes `1 + 2 = 3`, then `3 + 3 = 6`, yielding `Optional[6]`. Calling `get()` on a non-empty `Optional` returns the contained value `6`, which is printed.

Answer

Optional[6]

Answer

Optional.empty

Answer

NoSuchElementException

Question 5

Which statement about the Stream API is true?

Accepted Answer

A stream can be consumed only once.. A Stream in Java represents a sequence of elements that can be traversed only once. Once a terminal operation (like collect() or forEach()) is invoked on a stream, the stream is consumed and cannot be reused; attempting to do so throws an IllegalStateException. This one-time consumption is a fundamental design principle of the Stream API, ensuring that operations are applied to a single, immutable pipeline.

Answer

Parallel streams always improve performance.

Answer

Streams are always finite.

Answer

Intermediate operations are executed eagerly.

Question 6

Given: List words = Arrays.asList("apple", "banana", "cherry"); Map> map = words.stream().collect(Collectors.groupingBy(String::length)); System.out.println(map); What is the output?

Accepted Answer

{5=[apple], 6=[banana, cherry]}. The `groupingBy` collector groups stream elements by a classifier function, here `String::length`. Each distinct length becomes a key in the map, and the values are lists of strings with that length. "apple" (length 5) maps to key 5, "banana" and "cherry" (both length 6) map to key 6, producing `{5=[apple], 6=[banana, cherry]}`.

Answer

[apple, banana, cherry]

Answer

{5=[5], 6=[6, 6]}

Answer

{apple=[5], banana=[6], cherry=[6]}

Question 7

A developer wants to find the longest word in a list of strings. Which stream operation should be used?

Accepted Answer

stream().max(Comparator.comparingInt(String::length)). The `max()` terminal operation, when combined with a `Comparator` that compares strings by their length, returns the longest word in the stream. The `max()` operation uses the provided comparator to determine the 'largest' element according to the ordering, which in this case is the string with the greatest length.

Answer

stream().sorted(Comparator.comparingInt(String::length).reversed()).findFirst()

Answer

stream().min(Comparator.comparingInt(String::length))

Answer

stream().sorted(Comparator.comparingInt(String::length)).findFirst()

Question 8

What does the following code print?

List<Integer> list = List.of(1, 2, 3, 4, 5);
list.stream().filter(i -> i % 2 == 0).forEach(System.out::print);

Accepted Answer

24. The stream filters only even numbers (i % 2 == 0) from the list, producing 2 and 4, which are then printed sequentially via forEach. The filter operation retains elements where the predicate is true, so only 2 and 4 satisfy the condition.

Answer

No output

Answer

12345

Answer

135

Question 9

Which TWO are valid lambda expressions? (Choose two.)
A. (int a, int b) -> a + b
B. a, b -> a + b
C. (a, b) -> a + b
D. (a, b) -> { a + b; }
E. (int a, b) -> a + b

Accepted Answer

(int a, int b) -> a + b. Option A is correct because a lambda expression may declare explicit parameter types, and when it does, the parameter list must be enclosed in parentheses: (int a, int b) -> a + b is valid syntax. Option C is correct because a lambda may use inferred parameter types, and with two or more inferred parameters the parentheses are required: (a, b) -> a + b is valid. Option B is invalid because a lambda parameter list with multiple parameters must be enclosed in parentheses, so a, b -> a + b is not legal. Option D is invalid because a block-bodied lambda must contain statements, and a + b; is an expression, not a statement, so it would not compile. Option E is invalid because Java does not allow mixing explicit and inferred parameter types in the same lambda parameter list, so (int a, b) -> a + b is illegal.

Answer

a, b -> a + b

Answer

(a, b) -> { a + b; }

Answer

(int a, b) -> a + b

Question 10

Which TWO statements about the Stream API are correct? (Choose two.)
A. A stream can be traversed multiple times.
B. The peek() method is an intermediate operation.
C. The findFirst() method returns an Optional.
D. The collect() method is an intermediate operation.
E. The map() method returns a stream of the same type.

Accepted Answer

The peek() method is an intermediate operation.. Option B is correct because peek() is an intermediate operation in the java.util.stream API: it returns a new Stream, is lazy, and is typically used for debugging to inspect elements as they flow through the pipeline. Option C is correct because findFirst() is a short-circuiting terminal operation that returns Optional, wrapping the first element of the stream or an empty Optional if the stream is empty. Option A is incorrect because a stream is single-use: once a terminal operation is invoked, the stream is consumed and any attempt to traverse it again throws IllegalStateException. Option D is incorrect because collect() is a terminal operation that triggers pipeline execution and reduces the stream into a result container such as a List or Set, not an intermediate operation. Option E is incorrect because map() is a stateless intermediate operation that transforms each element via a Function and returns a Stream whose element type may differ from the source stream's type.

Answer

A stream can be traversed multiple times.

Answer

The collect() method is an intermediate operation.

Answer

The map() method returns a stream of the same type.

Question 11

A data analytics platform processes user activity logs. Each log entry is a LogRecord with fields: userId (int), action (String), timestamp (long). The requirement is to find the top 3 most active users (by count of actions) in the last hour. The logs are stored in a List<LogRecord> logs. The current solution sorts all records by userId and counts manually, but it's slow. The team decides to use streams with parallel processing. Which code correctly identifies the top 3 users?

Accepted Answer

logs.parallelStream().filter(l -> l.timestamp() > System.currentTimeMillis() - 3600000).collect(Collectors.groupingBy(LogRecord::userId, Collectors.counting())).entrySet().stream().sorted(Map.Entry.<Long, Long>comparingByValue().reversed()).limit(3).collect(Collectors.toList()). It first filters logs to only those within the last hour, then groups by userId and counts actions, sorts the resulting map entries by count in descending order, limits to the top 3, and collects the result. This uses parallelStream() for performance and correctly applies the required logic.

Answer

logs.parallelStream().filter(l -> l.timestamp() > System.currentTimeMillis() - 3600000).collect(Collectors.groupingBy(LogRecord::userId, Collectors.counting())).entrySet().stream().sorted(Map.Entry.comparingByKey()).limit(3).collect(Collectors.toList())

Answer

logs.parallelStream().collect(Collectors.groupingBy(LogRecord::userId, Collectors.counting())).entrySet().stream().sorted(Map.Entry.comparingByValue().reversed()).limit(3).collect(Collectors.toList())

Answer

logs.parallelStream().filter(l -> l.timestamp() > System.currentTimeMillis() - 3600000).collect(Collectors.groupingBy(LogRecord::action, Collectors.counting())).entrySet().stream().sorted(Map.Entry.comparingByValue().reversed()).limit(3).collect(Collectors.toList())

Question 12

Which TWO are correct about parallel streams in Java? (Choose TWO.)

Accepted Answer

Parallel streams use the common ForkJoinPool by default.. Option D is correct because parallel streams in Java execute their tasks on the common ForkJoinPool by default, which is obtained via ForkJoinPool.commonPool() and sized to Runtime.getRuntime().availableProcessors() - 1. Option E is correct because parallel stream pipelines require stateless, non-interfering, and side-effect-free lambda functions; shared mutable state or interference between operations can produce nondeterministic or incorrect results due to concurrent execution across threads. Option A is wrong because parallelism adds overhead (splitting, task scheduling, merging) and can be slower than sequential streams for small data sets or cheap operations. Option B is wrong because lambdas that mutate shared state, rely on encounter order, or are not thread-safe can break under parallel execution. Option C is wrong because parallel streams do not guarantee encounter order unless the terminal operation and stream source explicitly preserve it (e.g., using forEachOrdered), and unordered sources or operations may yield results in any order.

Answer

Parallel streams always improve performance over sequential streams.

Answer

Any lambda expression is safe to use in a parallel stream.

Answer

Using parallel streams guarantees the order of elements in the result.

Question 13

You are developing an online bookstore application. You have a list of Book objects, each with fields: String title, double price, and String genre. You need to generate a report that lists the total price of books in each genre, but only for genres where the average price is greater than $20.00. You are using Java 17 and streams. Which approach correctly accomplishes this task?

Accepted Answer

books.stream()
    .collect(Collectors.groupingBy(Book::getGenre,
             Collectors.mapping(Book::getPrice, Collectors.toList())))
    .entrySet().stream()
    .filter(e -> e.getValue().stream().mapToDouble(Double::doubleValue).average().orElse(0) > 20)
    .collect(Collectors.toMap(Map.Entry::getKey,
             e -> e.getValue().stream().mapToDouble(Double::doubleValue).sum()));. It first groups books by genre, collecting prices into lists, then filters entries where the average price exceeds $20 using `mapToDouble` and `average()`, and finally sums the prices for those genres. This two-step process correctly computes the average per genre before filtering, then sums the total per genre.

Answer

books.stream()
    .filter(b -> b.getPrice() > 20)
    .collect(Collectors.groupingBy(Book::getGenre,
             Collectors.summingDouble(Book::getPrice)));

Answer

books.stream()
    .collect(Collectors.groupingBy(Book::getGenre,
             Collectors.averagingDouble(Book::getPrice)))
    .entrySet().stream()
    .filter(e -> e.getValue() > 20)
    .collect(Collectors.toMap(Map.Entry::getKey, e -> {
        return books.stream().filter(b -> b.getGenre().equals(e.getKey())).mapToDouble(Book::getPrice).sum();
    }));

Answer

books.stream()
    .collect(Collectors.groupingBy(Book::getGenre,
             Collectors.summingDouble(Book::getPrice)))
    .entrySet().stream()
    .filter(e -> e.getValue() > 20)
    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

Question 14

A developer is designing a method that processes a stream of Employee objects. The method needs to group employees by department and then, within each department, sort by salary in descending order, and collect the top 3 highest-paid employees per department into a list. Which approach correctly accomplishes this using streams?

Accepted Answer

stream.collect(Collectors.groupingBy(Employee::getDepartment, Collectors.collectingAndThen(Collectors.toList(), list -> list.stream().sorted(Comparator.comparing(Employee::getSalary).reversed()).limit(3).collect(Collectors.toList())))). It uses `Collectors.groupingBy` to partition employees by department, then applies `Collectors.collectingAndThen` to post-process each department's list. Inside, it sorts the list by salary in descending order, limits to the top 3, and collects them into a new list. This ensures each department's result is independently sorted and truncated.

Answer

stream.collect(Collectors.toMap(Employee::getDepartment, e -> { List l = new ArrayList<>(); l.add(e); return l; }, (l1, l2) -> { l1.addAll(l2); l1.sort(Comparator.comparing(Employee::getSalary).reversed()); return l1.subList(0, Math.min(3, l1.size())); }))

Answer

stream.sorted(Comparator.comparing(Employee::getSalary).reversed()).collect(Collectors.groupingBy(Employee::getDepartment, Collectors.toList())).values().stream().map(l -> l.subList(0, Math.min(3, l.size()))).collect(Collectors.toList())

Answer

stream.collect(Collectors.groupingBy(Employee::getDepartment, Collectors.toList())).entrySet().stream().flatMap(e -> e.getValue().stream().sorted(Comparator.comparing(Employee::getSalary).reversed()).limit(3)).collect(Collectors.toList())

Question 15

Which TWO statements are true about the Stream API and lambda expressions in Java 17?

Accepted Answer

The Stream API does not modify the original data source.. Option A is correct because the Stream API is designed to be non-destructive: operations such as filter, map, and collect produce a new stream or result and never mutate the underlying source collection, array, or I/O channel. Option B is correct because lambda expressions may capture local variables from the enclosing scope only if those variables are final or effectively final (i.e., assigned exactly once), which preserves Java's rules for closures. Option C is wrong because a stream can be consumed by only one terminal operation; after that the stream is closed and any further terminal operation throws IllegalStateException. Option D is wrong because intermediate operations are lazy — they are not executed until a terminal operation is invoked, which enables short-circuiting and fusion. Option E is wrong because lambda expressions do not introduce a new level of scope like anonymous inner classes do; a lambda body shares the enclosing scope, so names like this and variables resolve to the enclosing context rather than to a new inner-class scope.

Answer

A stream can be consumed by multiple terminal operations sequentially.

Answer

Intermediate operations on a stream are executed eagerly.

Answer

Lambda expressions introduce a new level of scope, similar to an anonymous inner class.