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

Question 1

Order the steps to properly implement the Singleton pattern with lazy initialization in Java.

Accepted Answer

Step 1: Declare private static volatile instance variable; Step 2: Make constructor private; Step 3: Provide public static getInstance() method; Step 4: Inside getInstance, perform first null check, synchronize on class, second null check, then instantiate.. The correct order for implementing the Singleton pattern with lazy initialization and double-checked locking is A. The steps must follow a logical sequence: first declare the private static volatile instance variable to ensure visibility across threads, then make the constructor private to prevent external instantiation, then provide the public static getInstance method, and finally implement double-checked locking inside the method. Option B is incorrect because it declares the instance variable after making the constructor private, which is not the standard order; while functionally similar, the proper implementation requires declaring the volatile variable first. Option C places the private constructor after the getInstance method, allowing instantiation before the constructor is private. Option D puts the double-checked locking code before the method is provided, which is syntactically invalid.

Answer

Step 1: Make constructor private; Step 2: Declare private static volatile instance variable; Step 3: Provide public static getInstance() method; Step 4: Inside getInstance, perform first null check, synchronize on class, second null check, then instantiate.

Answer

Step 1: Declare private static volatile instance variable; Step 2: Provide public static getInstance() method; Step 3: Make constructor private; Step 4: Inside getInstance, perform first null check, synchronize on class, second null check, then instantiate.

Answer

Step 1: Declare private static volatile instance variable; Step 2: Make constructor private; Step 3: Inside getInstance, perform first null check, synchronize on class, second null check, then instantiate; Step 4: Provide public static getInstance() method.

Question 2

A stream pipeline uses groupingBy with a downstream collector to count occurrences. The developer expects a Map<Integer, Long> but gets a compilation error. Which is the correct way to write the collector?

Accepted Answer

Collectors.groupingBy(Function.identity(), Collectors.counting()). Options C and D are both correct ways to produce a Map<Integer, Long> using groupingBy with a downstream collector. Option C uses Collectors.counting(), which is the standard method for counting elements in each group. Option D uses Collectors.summingLong(e -> 1L) to sum a constant 1 for each element, effectively achieving the same count. Options A and B are incorrect: A uses toMap which is not a grouping operation, and B uses Collectors.count() which does not exist (the correct method is counting()).

Answer

Collectors.toMap(Function.identity(), e -> 1L, Long::sum)

Answer

Collectors.groupingBy(Function.identity(), Collectors.count())

Question 3

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(). Ly 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 4

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 5

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). 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 6

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 7

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 8

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 9

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 10

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 11

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. Options A and C are valid lambda expressions. Option A uses explicit parameter types, which is allowed in lambda expressions. Option C uses inferred types with parentheses, also valid. Option B is invalid because multiple lambda parameters require parentheses. Option D is invalid because the block body does not contain a return statement, and the expression statement a + b; is not a valid return statement. Option E is invalid because it mixes explicit and inferred parameter types; if one parameter has an explicit type, all must have explicit types.

Answer

a, b -> a + b

Answer

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

Answer

(int a, b) -> a + b

Question 12

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.. The correct statements are B and C. Option B is correct because peek() is an intermediate operation that allows performing an action on each element without modifying the stream. Option C is correct because findFirst() returns an Optional describing the first element, or an empty Optional if the stream is empty. Option A is incorrect because a stream can only be consumed once; it cannot be traversed multiple times. Option D is incorrect because collect() is a terminal operation, not an intermediate operation. Option E is incorrect because map() can change the element type; for example, mapping a Stream to Stream is common.

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 13

Which TWO statements about lambda expressions are true? (Choose two.)
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 be assigned to a functional interface variable.. False: A lambda expression can only throw checked exceptions that are declared in the functional interface's abstract method, not any checked exception. Options B and C are true: a lambda can be assigned to a functional interface variable, and it can access final or effectively final local variables. Option D is false: a lambda can only implement one abstract method (functional interface). Option E is false: lambdas cannot instantiate abstract classes; they only implement functional interfaces.

Answer

A lambda expression can throw any checked exception.

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 14

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()))). 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 15

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 16

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()). 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 17

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

Accepted Answer

Parallel streams use the common ForkJoinPool by default.. 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.

Question 18

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 19

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 20

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.. The Stream API is designed to work on a view of the data, not the data itself. Operations like filter, map, and collect produce new streams or results without altering the original collection, array, or I/O source. This non-interference guarantee is a core principle of the Stream API, ensuring safe parallel execution and functional programming style.

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.