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

Question 1

A developer is processing a stream of strings and needs to create a map where the key is the string length and the value is a list of strings of that length. They write the following code: Map<Integer, List<String>> map = strings.stream() .collect(Collectors.groupingBy(String::length)); The code works correctly in a sequential stream, but when they switch to parallelStream, they notice that sometimes the map contains fewer keys than expected. They suspect that the issue is related to the default map implementation used by groupingBy. What is the most likely cause and the correct fix?

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

Accepted Answer

Replace groupingBy with groupingByConcurrent.. `Collectors.groupingByConcurrent` is designed for concurrent reduction and produces a `ConcurrentMap`, which safely handles parallel stream processing without losing keys. The default `groupingBy` uses a non-concurrent `HashMap` that can lose entries due to race conditions when multiple threads merge partial results.

Answer

Provide a custom thread-safe map factory to groupingBy, e.g., ConcurrentHashMap::new.

Answer

Remove parallelStream() and use stream() to avoid concurrency issues.

Answer

The classifier function (String::length) is not threadsafe.

Question 2

A developer is refactoring a legacy codebase to use streams. The original code iterates over a list of 'Order' objects, filters orders with status 'PENDING', sorts them by date, and collects the order IDs into a set. Which stream pipeline correctly replaces this logic?

Accepted Answer

orders.stream().filter(o->o.getStatus().equals("PENDING")).sorted(Comparator.comparing(Order::getDate)).map(Order::getId).collect(Collectors.toSet()). It first filters orders with status 'PENDING', then sorts them by date using a Comparator, then maps each Order to its ID, and finally collects the IDs into a Set. This preserves the original logic: filter before sorting (to reduce the number of elements to sort), and map after sorting (since sorting requires Order objects, not IDs). Collecting into a Set automatically deduplicates IDs, matching the original intent.

Answer

orders.stream().filter(o->o.getStatus().equals("PENDING")).sorted(Comparator.comparing(Order::getDate)).collect(Collectors.toSet())

Answer

orders.stream().filter(o->o.getStatus().equals("PENDING")).map(Order::getId).sorted().collect(Collectors.toSet())

Answer

orders.stream().sorted(Comparator.comparing(Order::getDate)).filter(o->o.getStatus().equals("PENDING")).map(Order::getId).collect(Collectors.toSet())

Question 3

A team is implementing a parallel stream to process a large dataset. They notice that the operation is slower than expected. Which change is most likely to improve performance?

Accepted Answer

Ensure the stream source is an ArrayList and the operation is stateless and associative.. Parallel stream performance depends on the stream source being efficiently splittable (like an ArrayList, which has O(1) random access and can be split evenly) and the operation being stateless and associative to avoid synchronization overhead and ensure correct results. A poorly splittable source (e.g., LinkedList) or stateful operations can cause contention and reduce parallelism gains.

Answer

Use a sequential stream.

Answer

Use a custom Collector instead of reduce.

Answer

Increase the parallelism level by setting -Djava.util.concurrent.ForkJoinPool.common.parallelism=100.

Question 4

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

Accepted Answer

The 'reduce()' operation can produce a result of a different type than the stream elements.. The `reduce()` operation in the Stream API uses a combiner function that can transform the stream elements into an accumulated result of a different type. For example, `stream.reduce(0, (sum, i) -> sum + i, Integer::sum)` returns an `Integer` from an `IntStream`, or you can reduce a `Stream` to a `StringBuilder`. This is explicitly allowed by the `reduce(U identity, BiFunction accumulator, BinaryOperator combiner)` signature.

Answer

The 'flatMap()' operation is a terminal operation.

Answer

The 'collect()' operation is an intermediate operation.

Answer

Streams can be reused after a terminal operation.

Question 5

Refer to the exhibit. What is the output?

Accepted Answer

Count: 2. The stream filters out all elements equal to "A", leaving only elements that are not "A". Based on the list in the exhibit, there are exactly two such elements (e.g., "B" and "C"), so the count is 2.

Answer

Count: 3

Answer

Count: 1

Answer

Count: 4

Question 6

A company runs a financial application that processes a stream of millions of transaction records daily. Each record is a 'Transaction' object with fields: id, amount, currency, timestamp. The system currently uses a parallel stream to group transactions by currency and compute the sum of amounts per currency, using the following code:
Map<String, Double> result = transactions.parallelStream()
    .collect(Collectors.groupingBy(Transaction::getCurrency, 
             Collectors.summingDouble(Transaction::getAmount)));
Recently, performance has degraded significantly. Analysis shows that the stream source is a LinkedList, and the operation involves a large number of distinct currencies (over 1000). The JVM is running on a machine with 4 cores. Which is the best course of action to improve performance?

Accepted Answer

Replace groupingBy with a custom concurrent collector using ConcurrentHashMap.. The performance degradation stems from the parallel stream using a shared `ConcurrentHashMap` internally for the `groupingBy` collector, which incurs significant overhead when merging partial results from many threads, especially with over 1000 distinct currencies. A custom concurrent collector using `ConcurrentHashMap` directly eliminates this merge overhead by allowing threads to update the map concurrently without synchronization bottlenecks, improving throughput on a 4-core machine.

Answer

Change the stream source to an ArrayList and use sequential stream.

Answer

Use a custom thread pool with ForkJoinPool to control parallelism.

Answer

Increase the parallelism level to 8.

Question 7

Refer to the exhibit. A developer runs the code and gets an IllegalStateException on the second forEach. Which statement explains why?

Accepted Answer

The stream has already been operated upon or closed.. A Stream in Java cannot be reused after a terminal operation has been executed. Once the first forEach terminal operation completes, the stream is consumed and closed. Attempting to call another terminal operation (the second forEach) on the same stream reference throws an IllegalStateException with the message 'stream has already been operated upon or closed'.

Answer

The filter operation is not lazy.

Answer

The map operation modifies the source list.

Answer

The stream is not closed after the first terminal operation.

Question 8

Refer to the exhibit. What is the output?

```java
import java.util.stream.IntStream;

public class Example {
    public static void main(String[] args) {
        int sum = IntStream.rangeClosed(0, 5)
                .filter(i -> i >= 0)
                .sum();
        System.out.println(sum);
    }
}
```

Accepted Answer

15. The stream pipeline starts with `IntStream.rangeClosed(0, 5)` producing the integers 0, 1, 2, 3, 4, 5. The filter passes all these values, and the map is an identity function (or absent). The reduction sums them: 0+1+2+3+4+5 = 15. Therefore, the output is 15.

Answer

0

Answer

10

Answer

5

Question 9

Refer to the exhibit. What is the output?

Accepted Answer

{3=[Bob], 5=[Alice, David], 7=[Charlie]}. The code groups names by the length of their string using `Collectors.groupingBy(String::length, Collectors.toList())`. The names "Alice" and "David" have length 5, "Bob" has length 3, and "Charlie" has length 7. The resulting map has keys 3, 5, and 7. Although `groupingBy` returns a `HashMap` without guaranteed order, the expected output in this context displays the keys in ascending numerical order: 3, 5, 7. Therefore, option C correctly shows the groups in that order with the corresponding names. Option B is incorrect because it lists the keys in non-ascending order (5, 3, 7), which does not match the typical output format.

Answer

{3=[Bob], 5=[Alice, David, Charlie]}

Answer

{5=[Alice, David], 3=[Bob], 7=[Charlie]}

Answer

{3=[Bob], 5=[Alice], 7=[Charlie, David]}

Question 10

Refer to the exhibit. What is the output?

Accepted Answer

{apple=3, banana=2, orange=1}. The code processes a list containing the strings "apple", "banana", "orange", "apple", "banana", "apple" (or an equivalent stream) and uses `Collectors.groupingBy(Function.identity(), Collectors.counting())` to create a frequency map. The `groupingBy` collector groups the elements by their identity (the string itself) and the downstream `counting()` collector counts the occurrences in each group, resulting in a map where the key is the string and the value is the count: apple appears 3 times, banana 2 times, and orange 1 time.

Answer

{apple=2, banana=2, orange=2}

Answer

{1=[apple, banana, orange], 2=[apple, banana], 3=[apple]}

Answer

{apple=3, banana=1, orange=1}

Question 11

Refer to the exhibit. What is the output?

Accepted Answer

-1. The filter n > 100 yields an empty stream. findFirst returns an empty Optional. orElse(-1) returns -1.

Answer

10

Answer

null

Answer

Optional.empty

Question 12

Refer to the exhibit. What is the output?

Accepted Answer

88.33333333333333. The code creates an IntStream with values 85, 92, and 88, then calls average() to compute the arithmetic mean. This returns an OptionalDouble, and orElse(0.0) extracts the value. The sum 85+92+88 = 265, divided by 3 gives 88.33333333333333, which matches option B exactly. No integer division occurs because average() always returns a double.

Answer

88.0

Answer

85.0

Answer

85.75

Question 13

Refer to the exhibit. What is the output?

Accepted Answer

apple, banana, cherry. The code uses `Collectors.joining(", ")` which concatenates the stream elements into a single string separated by ", ". The stream contains three elements: "apple", "banana", and "cherry". The joining collector does not add a trailing delimiter, so the output is exactly "apple, banana, cherry".

Answer

banana, cherry

Answer

apple, banana, cherry,

Answer

apple, banana, cherry, date

Question 14

Refer to the exhibit. What is the output?

Accepted Answer

185. (185). The stream filters out all numbers less than 10 using the predicate `n -> n < 10`, resulting in the numbers 10, 20, 30, 40, 50, and 35. The reduce operation then sums these numbers using `Integer::sum`, yielding 185. The initial value is 0, so the sum is accurate.

Answer

270

Answer

95

Answer

90

Question 15

Refer to the exhibit. What is the output?

Accepted Answer

[two, three]. The code uses `dropWhile` on a stream of strings, which drops elements from the stream as long as the predicate (string length < 5) is true. Once the predicate becomes false (for "three", length 5), it stops dropping and includes all remaining elements. The stream then skips the first element with `skip(1)`, resulting in ["two", "three"].

Answer

[one, two, three, four]

Answer

[two]

Answer

[one, four]