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

Question 1

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

Accepted Answer

Is stateless. A well-designed lambda expression should be stateless, meaning it does not depend on or modify mutable state from the enclosing scope. This ensures that the lambda can be safely executed in parallel streams without race conditions or side effects, aligning with the functional programming paradigm promoted by Java streams.

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 2

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

Accepted Answer

Arrays.stream(new String[]{"a", "b"}). `Arrays.stream(T[])` returns a `Stream` from an array. Passing `new String[]{"a", "b"}` creates a `Stream` directly, as the method is overloaded for object arrays.

Answer

"ab".chars()

Answer

new Stream<String>()

Question 3

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

Accepted Answer

Optional.empty().orElseThrow(IllegalStateException::new) throws IllegalStateException. `Optional.empty().orElseThrow(IllegalStateException::new)` explicitly throws a new `IllegalStateException` when the Optional is empty. The `orElseThrow` method is designed to throw the provided exception supplier's exception if no value is present.

Answer

Optional.of(null) returns an empty Optional

Answer

Optional.get() on empty Optional returns null

Question 4

Refer to the exhibit. What is the result?

Accepted Answer

IllegalStateException. The code attempts to call `findAny()` on a `Stream` that has already been consumed by a terminal operation (`forEach`). Once a terminal operation is executed on a stream, the stream is closed and cannot be reused. Any subsequent call to a terminal operation on the same stream reference throws `IllegalStateException`. Option C is correct because the second terminal operation violates the single-use contract of streams.

Answer

abc

Answer

NullPointerException

Answer

abcabc

Question 5

Refer to the exhibit. What is the output?

Accepted Answer

12. (12). The exhibit shows a stream reduction with identity value 1 and elements 2, 3, 2. The reduce operation multiplies each element with the accumulated result: 1 * 2 = 2, 2 * 3 = 6, 6 * 2 = 12. The identity is the starting accumulator, not a stream element.

Answer

30

Answer

0

Answer

20

Question 6

A company runs a Java 17 microservice that processes real-time financial transactions. The application receives a large number of transactions per second, each with a timestamp, amount, and type. The current implementation uses a sequential stream to filter and aggregate transactions into a Map. The team observes high latency and CPU spikes during peak loads. They suspect the stream pipeline is inefficient. The pipeline code is: Map stats = transactions.stream() .filter(t -> t.getTimestamp().isAfter(Instant.now().minusSeconds(60))) .collect(Collectors.groupingBy(Transaction::getType, Collectors.summarizingDouble(Transaction::getAmount))); The transactions list is an ArrayList that is frequently modified by other threads (adding new transactions). The system has multiple CPU cores available. Which of the following changes is the MOST effective way to improve performance while maintaining correctness?

Accepted Answer

Use .parallelStream() on a snapshot (new ArrayList<>(transactions)) and keep the same collector.. Taking a snapshot via new ArrayList<>(transactions) provides a consistent, immutable view for the stream, reducing contention and allowing parallelStream to leverage multiple cores. However, the copy operation itself is not thread-safe and can throw ConcurrentModificationException if the list is being modified simultaneously. Despite this risk, option B is the most effective among the choices because it attempts to isolate the stream from concurrent modifications and uses a parallel-friendly collector. To guarantee correctness, additional synchronization would be required, but none of the other options offer a better combination of performance and safety.

Answer

Use .stream().parallel() with a custom thread pool and ensure the stream source is not modified during operation.

Answer

Replace ArrayList with CopyOnWriteArrayList and use .parallelStream() with the same collector.

Answer

Replace the collector with Collectors.groupingByConcurrent() and use .parallelStream() directly on the original list.

Question 7

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 8

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 9

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 10

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

Accepted Answer

It is primarily used for debugging purposes.. The `peek` method is designed as a debugging aid to observe elements as they flow through a stream pipeline. It performs the provided action on each element without modifying them, making it ideal for logging or printing intermediate states.

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.

Question 11

Which three are terminal operations of the Stream interface? (Choose three.)

Accepted Answer

reduce. (reduce) is correct because it is a terminal operation that processes all elements of a stream to produce a single result (e.g., sum, concatenation). Terminal operations trigger the stream pipeline execution and close the stream, after which no further operations can be performed.

Answer

filter

Answer

map

Question 12

A financial application processes millions of transactions daily. The original code uses a for loop to aggregate transactions into a Map<Long, TransactionSummary> where the key is account ID. To improve performance, a developer refactors it using parallel streams: transactions.parallelStream() .collect(Collectors.toMap( Transaction::getAccountId, Function.identity(), (t1, t2) -> t1.merge(t2), // merging logic HashMap::new )); After deployment, they observe that the resulting map is smaller than expected and some transaction summaries are missing. Profiling shows the merge function is called infrequently, suggesting that the map is losing entries. What is the most likely cause and the correct fix?

Accepted Answer

Replace HashMap::new with ConcurrentHashMap::new in the collector.. The issue is that `HashMap::new` is not thread-safe. When `parallelStream()` splits the stream into multiple threads, each thread creates its own `HashMap` for partial results. These partial maps are then merged using the collector's combiner, but `HashMap` does not guarantee thread safety during concurrent access or merging. Using `ConcurrentHashMap::new` ensures that the map can be safely populated and combined across threads, preventing lost entries. The merge function itself is associative (merging two summaries into one), so the problem is purely the thread-unsafe map supplier.

Answer

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

Answer

The merge function is not associative; change it to use a combiner that is associative.

Answer

Use forEach with a ConcurrentHashMap and putIfAbsent to manually merge.

Question 13

A team is developing a real-time data processing pipeline that reads sensor data from a message queue. The pipeline uses a flatMap operation that calls an external geocoding service for each sensor reading. The external service has a rate limit of 10 requests per second and is slow (150ms average response time). The current code: sensorStream.parallelStream() .flatMap(reading -> getGeocode(reading).stream()) .forEach(system.out::println); The application is overloaded because parallel stream fires many concurrent requests, exceeding the rate limit and causing failures. They need to process all sensor data but must respect the rate limit. Which approach should they use?

Accepted Answer

Use a sequential stream with a custom rate limiter (e.g., a semaphore) that blocks when the limit is reached.. Using a sequential stream with a custom rate limiter (e.g., a Semaphore configured to allow only 10 permits per second) ensures that the external geocoding service is called at a controlled rate, preventing rate-limit violations. The sequential stream processes elements one at a time, and the rate limiter blocks the thread when the limit is reached, naturally throttling requests to stay within the 10 requests/second limit while still processing all data.

Answer

Reduce the parallelism level by using a custom thread pool with a fixed number of threads.

Answer

Use filter to drop some sensor readings to reduce the load.

Answer

Use a sequential stream and hope the processing completes within the time window.

Question 14

A developer is converting legacy for loops to streams. The legacy code: List list = new ArrayList<>(); for (String s : strings) { if (s.length() > 5) { list.add(s.length()); } } They write: List list = strings.stream() .filter(s -> s.length() > 5) .map(s -> s.length()) .collect(Collectors.toList()); But it doesn't compile. The error is: 'cannot find symbol: method collect(Collector>)'. What is the likely issue?

Accepted Answer

The map operation returns an IntStream, which does not have a collect method. Use map(s -> s.length()).boxed().collect(...) or mapToInt(...).boxed().. The issue is that `map(s -> s.length())` on a `Stream` returns an `IntStream`, not a `Stream`. The `IntStream` interface does not have a `collect(Collector)` method; it only has `collect(Supplier, BiConsumer, BiConsumer)`. To use `Collectors.toList()`, you must convert the `IntStream` back to a `Stream` via `.boxed()`, or use `mapToInt(...).boxed()`, or use `map(s -> (Integer) s.length())` to keep a `Stream`.

Answer

The lambda in filter is incorrectly written; it should be s.length > 5.

Answer

The stream should be made unordered to allow the collector to function.

Answer

Use parallelStream() to enable the collect method.

Question 15

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?

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.