1Z0-829 Working with Streams and Lambda Expressions — Timed 15 Questions

Question 1

A company processes financial transactions. Each transaction is represented by a Transaction object with fields: amount (double), currency (String), and type (String). The requirement is to compute the total amount of all transactions of type 'SALE' in USD. The transactions are stored in a List<Transaction>. Which code correctly accomplishes this using streams?

Accepted Answer

transactions.stream().filter(t -> t.type().equals("SALE") && t.currency().equals("USD")).mapToDouble(Transaction::amount).sum(). Option D correctly filters transactions to only those with type 'SALE' and currency 'USD', then maps each to its amount as a double, and sums them using sum(). This satisfies the requirement exactly: total amount of 'SALE' transactions in USD.

Answer

transactions.stream().mapToDouble(Transaction::amount).filter(t -> t.type().equals("SALE")).sum()

Answer

transactions.stream().filter(t -> t.type().equals("SALE")).filter(t -> t.currency().equals("USD")).mapToDouble(Transaction::amount).sum()

Answer

transactions.stream().map(Transaction::amount).reduce(0.0, (a, b) -> a + b)

Question 2

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 correct answer is A because 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 3

A developer needs to process a stream of integers and collect the results into a Map> where keys are the integers themselves and values are lists containing the number and its square. Which collector should be used?

Accepted Answer

Collectors.toMap(Function.identity(), i -> Arrays.asList(i, i * i), (v1, v2) -> v1, HashMap::new). Option C is correct because it uses the four-argument overload of `Collectors.toMap()`: a key mapper (`Function.identity()`), a value mapper (a lambda that creates a `List` containing the number and its square), a merge function (`(v1, v2) -> v1`) to handle duplicate keys (which won't occur here since keys are unique integers), and a `HashMap::new` supplier to ensure the map type is explicitly `HashMap`. This satisfies the requirement of producing a `Map>` where each key maps to a list of the number and its square.

Answer

Collectors.toMap(Function.identity(), i -> Arrays.asList(i, i * i), (v1, v2) -> v1)

Answer

Collectors.groupingBy(Function.identity(), Collectors.mapping(i -> i * i, Collectors.toList()))

Answer

Collectors.toMap(Function.identity(), i -> i * i)

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.. Option D is correct because 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)). Option D is correct because 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 correct answer is D because 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

(a, b) -> a + b. Option B is correct because a lambda expression with inferred parameter types can omit the parameter types and parentheses when there is exactly one parameter, but here there are two parameters, so parentheses are required. Option C is correct because it explicitly declares the types of both parameters, which is valid syntax for a lambda expression that returns the sum of the two integers.

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 A is correct because the `peek()` method is an intermediate operation in the Stream API. Intermediate operations return a new stream and are lazy; they are not executed until a terminal operation is invoked. `peek()` allows you to inspect elements as they flow through the pipeline without modifying them.

Answer

The collect() method is an intermediate operation.

Answer

A stream can be traversed multiple times.

Answer

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

Question 11

Which THREE statements about lambda expressions are true? (Choose three.)
A. A lambda expression can be assigned to a functional interface variable.
B. A lambda expression can access final or effectively final local variables.
C. A lambda expression can throw any checked exception.
D. A lambda expression can be used to create an instance of an abstract class.
E. A lambda expression can be used to implement multiple abstract methods.

Accepted Answer

A lambda expression can throw any checked exception.. Option A is correct because a lambda expression can be assigned to a variable of a functional interface type. The lambda provides the implementation for the single abstract method of that interface, and the assignment is valid as long as the lambda's parameter types and return type match the method signature.

Answer

A lambda expression can be used to implement multiple abstract methods.

Answer

A lambda expression can be used to create an instance of an abstract class.

Question 12

A financial services company has a microservice that processes trade confirmations. The service receives a stream of Trade objects (with fields: id (long), symbol (String), quantity (int), price (double)) and needs to compute the total value (quantity * price) for each symbol, but only for trades with quantity > 0 and price > 0. The result should be a Map mapping symbol to total value. The current implementation uses a for loop with manual aggregation, but it is error-prone and difficult to parallelize. The team decides to refactor using the Stream API. The DataSource provides a Stream trades(). The code must be efficient and handle large datasets. Which approach best meets these requirements?

Accepted Answer

trades().filter(t -> t.quantity() > 0 && t.price() > 0).collect(Collectors.groupingBy(Trade::symbol, Collectors.summingDouble(t -> t.quantity() * t.price()))). Option A is correct because it uses `Collectors.groupingBy` with a downstream `Collectors.summingDouble` collector, which is the idiomatic and efficient way to group trades by symbol and sum their computed values (quantity * price) after filtering out invalid trades. This approach is concise, leverages the Stream API's built-in parallelization support, and avoids manual accumulation or mutable state issues.

Answer

trades().filter(t -> t.quantity() > 0 && t.price() > 0).collect(Collectors.toMap(Trade::symbol, t -> t.quantity() * t.price(), Double::sum))

Answer

trades().filter(t -> t.quantity() > 0 && t.price() > 0).collect(Collectors.toMap(Trade::symbol, t -> t.quantity() * t.price(), (v1, v2) -> v1 + v2))

Answer

trades().filter(t -> t.quantity() > 0 && t.price() > 0).reduce(new HashMap<>(), (map, t) -> { map.merge(t.symbol(), t.quantity() * t.price(), Double::sum); return map; }, (m1, m2) -> { m1.putAll(m2); return m1; })

Question 13

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()). Option A is correct because 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 14

A company needs to process a stream of orders and filter out orders that are not in the 'SHIPPED' status. Then they want to collect the order IDs into a list. Which of the following correctly uses lambda expressions to achieve this?

Accepted Answer

orders.stream().filter(o -> o.getStatus().equals("SHIPPED")).map(Order::getId).collect(Collectors.toList()). Option D is correct because it first filters the stream to include only orders with status 'SHIPPED' using a lambda expression that calls equals() on the status string, then maps each order to its ID using a method reference, and finally collects the IDs into a list. This correctly uses lambda expressions and the Stream API to achieve the requirement.

Answer

orders.stream().filter(o -> o.getStatus() != "SHIPPED").map(Order::getId).collect(Collectors.toList())

Answer

orders.stream().map(Order::getId).filter(id -> id.equals("SHIPPED")).collect(Collectors.toList())

Answer

orders.stream().filter(Order::getStatus).map(o -> o.getId()).collect(Collectors.toList())

Question 15

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, by default, use the common ForkJoinPool (ForkJoinPool.commonPool()), which is a shared thread pool designed for parallel task execution. This pool is lazily initialized and has a default parallelism level equal to the number of available processors minus one, as per the ForkJoinPool implementation.

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.