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

Question 1

A company uses a large dataset of customer orders. They want to compute statistics: total orders, average amount, and maximum amount per city. They write: Map<String, IntSummaryStatistics> stats = orders.stream() .collect(Collectors.groupingBy(Order::getCity, Collectors.summarizingInt(Order::getAmount))); The code works but is slower than expected when run on a large dataset. They suspect the grouping operation is not taking advantage of parallelism. They want to improve performance by making the collector concurrent. Which change is correct?

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

Accepted Answer

Use Collectors.groupingByConcurrent(Order::getCity, Collectors.summarizingInt(Order::getAmount)).. `Collectors.groupingByConcurrent` performs an unordered, concurrent reduction that can leverage a `ConcurrentHashMap` internally, allowing the collector to work efficiently with a parallel stream. This reduces contention and improves performance on large datasets compared to the sequential `groupingBy`.

Answer

Use parallelStream() instead of stream().

Answer

Keep the code but supply a ConcurrentHashMap as the map supplier to groupingBy.

Answer

Replace collect with forEach and manually update a ConcurrentHashMap.

Question 2

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> 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?

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 3

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 4

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 5

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 6

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 7

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 8

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 9

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 10

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 11

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]

Question 12

Refer to the exhibit. What is the output?

Accepted Answer

-15. The code uses `reduce(0, (a, b) -> a - b)` on a stream of integers. This operation starts with an identity value of 0 and applies the subtraction lambda cumulatively: 0 - 1 = -1, then -1 - 2 = -3, then -3 - 3 = -6, then -6 - 4 = -10, then -10 - 5 = -15. Therefore, the output is -15, making option C correct.

Answer

1

Answer

15

Answer

0

Question 13

A developer is building a pipeline over a Stream<String> of product names and wants to obtain a single String that concatenates all names, separated by commas, without a leading or trailing delimiter. Which two Collector implementations from java.util.stream.Collectors accomplish this directly? (Choose two.)

Accepted Answer

Collectors.joining(",", "", ""). Collectors.joining is purpose-built for concatenating CharSequence elements with a delimiter. The one-argument form inserts only the delimiter, and the three-argument form lets you specify prefix and suffix; supplying empty strings for both reproduces the delimiter-only behavior. Both produce a single String with commas between names and nothing at the ends.

Answer

Collectors.groupingBy(Function.identity())

Answer

Collectors.toList()

Answer

Collectors.reducing("", (a, b) -> a + "," + b)

Question 14

A developer needs to process a stream of transaction amounts (double values) to compute the total sum and also find the maximum amount. Which two code fragments correctly achieve these tasks using the Stream API? (Choose two.)

Accepted Answer

OptionalDouble max = transactions.stream().mapToDouble(Double::doubleValue).max();. The correct fragments are those that use mapToDouble to convert to a primitive stream and then apply sum() or max(). These operations are efficient and avoid boxing. The other options either cause compilation errors or are not among the two correct answers because they do not provide both required operations or are less optimal.

Answer

double total = transactions.stream().reduce(0.0, Double::sum);

Answer

Optional<Double> max = transactions.stream().max(Double::compare);

Answer

double total = transactions.stream().mapToDouble(d -> d).sum();

Question 15

A developer is building a pipeline over a Stream<Employee> where Employee has a getName method returning String. The developer wants to transform each employee into an uppercase name string and then sort the resulting strings alphabetically. Which two code fragments correctly accomplish this? (Choose two.)

Accepted Answer

stream.map(e -> e.getName().toUpperCase()).sorted().collect(Collectors.toList()). The goal requires uppercasing each name before sorting. Mapping to the name and then to uppercase, or doing both in one lambda, followed by sorted and collect, achieves this. Sorting before uppercasing can change the order, sorting employees without uppercasing misses the transformation, and applying String::toUpperCase directly to an Employee does not compile.

Answer

stream.map(Employee::getName).sorted().map(String::toUpperCase).collect(Collectors.toList())

Answer

stream.sorted(Comparator.comparing(Employee::getName)).map(Employee::getName).collect(Collectors.toList())

Answer

stream.map(String::toUpperCase).map(Employee::getName).sorted().collect(Collectors.toList())