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

Question 1

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

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

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

Question 4

The code fails to compile. What is the reason?

Accepted Answer

The flatMap method requires a function that returns a Stream, but String::chars returns an IntStream.. Option D is correct because the `chars()` method on `String` returns an `IntStream`, not a `Stream`. The `flatMap` method on a `Stream` expects a function that returns a `Stream`, but `String::chars` returns an `IntStream`, which is a primitive stream and not a subtype of `Stream`. This type mismatch causes a compilation error.

Answer

The collect method is not applicable for a Stream<Character>.

Answer

The method reference String::chars is not a valid method reference.

Answer

The chars() method returns a Stream, but flatMap requires a function that returns a Stream.

Question 5

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

Question 6

Match each exception class to its category (checked/unchecked).

Question 7

A developer wants to count how many strings in a list have length greater than 5. Which is the correct implementation?

Accepted Answer

list.stream().filter(s -> s.length() > 5).count(). Option B is correct because the Stream API provides the `filter` method to select elements matching a predicate, and `count` returns the number of elements in the resulting stream. This directly counts strings with length greater than 5 without needing any intermediate mapping or collection.

Answer

list.stream().mapToLong(s -> s.length() > 5).sum()

Answer

list.stream().count(s -> s.length() > 5)

Answer

list.stream().collect(Collectors.counting(s -> s.length() > 5))

Question 8

A team needs to process a large collection of orders to calculate total revenue per region. They decide to use parallel streams to improve performance. Which statement about using parallel streams for this task is true?

Accepted Answer

Using a parallel stream with a stateful lambda operation can lead to incorrect results.. Option B is correct because parallel streams split the workload across multiple threads, and if the lambda operation is stateful (e.g., modifying a shared variable like a counter or a non-thread-safe collection), it can cause race conditions and produce incorrect results. The Streams API documentation explicitly warns against using stateful lambdas with parallel streams to avoid data integrity issues.

Answer

The stream() method returns a parallel stream by default.

Answer

Parallel streams always provide better performance than sequential streams.

Answer

Parallel streams cannot be used with custom thread pools.

Question 9

Given a list of integers, a developer wants to compute the sum of squares of numbers greater than 10. The following code is written:
int sum = list.stream().filter(i -> i>10).mapToInt(i->i*i).sum();
But the sum is incorrect. What is the most likely reason?

Accepted Answer

The list might contain nulls causing NullPointerException.. Option C is correct because if the list contains null elements, the lambda expression `i -> i > 10` will attempt to unbox a null `Integer` to an `int`, causing a `NullPointerException` at runtime. The stream pipeline itself is syntactically valid, but the presence of nulls in the source list is a common pitfall when using primitive-specialized operations like `mapToInt` after a filter that does not guard against nulls.

Answer

The mapToInt operation is not allowed after filter.

Answer

The stream is not sorted.

Answer

The filter should be before mapToInt, but it is after.

Answer

The sum() method returns an OptionalInt and must be orElse(0).

Question 10

Which functional interface is most appropriate for a lambda that takes a String and returns nothing?

Accepted Answer

Consumer. Option A is correct because Consumer has an accept method that takes a String and returns void. Option B (Function) is not idiomatic; Consumer is designed for side effects.

Answer

Predicate<String>

Answer

Function<String, Void>

Answer

Supplier<String>

Question 11

A developer wants to create a stream that repeatedly generates random integers. Which method should be used?

Accepted Answer

IntStream.generate(() -> new Random().nextInt()). Option C is correct because `IntStream.generate()` accepts a `Supplier<Integer>` and produces an infinite sequential unordered stream, making it ideal for repeatedly generating random integers. The lambda `() -> new Random().nextInt()` supplies a new random integer each time the stream is evaluated, fulfilling the requirement exactly.

Answer

IntStream.range(0, 100)

Answer

Stream.of(new Random().nextInt())

Answer

Stream.iterate(0, i -> new Random().nextInt())

Question 12

A developer implements a reduction using reduce() to concatenate strings from a stream. The code: Optional<String> result = stream.reduce((s1, s2) -> s1.concat(s2)); The operation works but the developer is concerned about performance with large streams. Which change would most likely improve performance?

Accepted Answer

Use StringBuffer with collect() instead.. Option A is correct because `StringBuffer` is mutable and thread-safe, making it efficient for accumulating strings in a parallel or sequential stream via `collect()`. The `reduce()` operation with `concat()` creates a new `String` object for each pair, leading to O(n) string copying and quadratic time complexity. Using `collect()` with `StringBuffer` avoids this overhead by reusing a mutable buffer.

Answer

Use a sequential stream.

Answer

Use parallelStream with reduce.

Answer

Use reduce with identity "".

Question 13

Which code will successfully produce an Optional<Integer> that contains the maximum value from a list of integers?

Accepted Answer

B and C both produce Optional.. Option A is correct because both B and C produce an Optional containing the maximum value from the list. Option B uses Collectors.maxBy with Integer::compareTo, which returns an Optional. Option C uses the max() method on an IntStream (obtained via list.stream().mapToInt(Integer::intValue)), which returns an OptionalInt, not Optional. However, the question asks for an Optional, and Option C's max() on a Stream (not IntStream) returns Optional directly. Since the question's context implies a Stream, Option C is valid. Option D is incorrect because max(Integer::compareTo) is not a valid method on Stream; the correct method is max(Comparator) which returns Optional, but the syntax in D is missing the comparator argument properly—it should be max(Comparator.naturalOrder()) or similar, not max(Integer::compareTo) as a method reference without a comparator context. Thus, only B and C produce Optional.

Answer

list.stream().collect(Collectors.maxBy(Integer::compareTo))

Answer

list.stream().max()

Answer

list.stream().max(Integer::compareTo)

Question 14

A developer writes: list.stream().collect(Collectors.groupingBy(Function.identity(), Collectors.counting())); What is the result type and content?

Accepted Answer

Both A and B.. The correct answer is A because both B and C accurately describe the result. The code uses `Collectors.groupingBy(Function.identity(), Collectors.counting())`, which returns a `Map<T, Long>` where `T` is the element type of the stream. The map contains the number of occurrences of each distinct element, effectively a frequency count. Option D is incorrect because `groupingBy` without a specified map supplier returns a `HashMap`, not a `ConcurrentMap`.

Answer

Map<T, Long> where T is element type.

Answer

Map<Object, Long> with number of occurrences of each element.

Answer

A ConcurrentMap.

Question 15

Given: List<String> words = List.of("apple", "banana", "cherry");
var result = words.stream().filter(s -> s.length() > 5).collect(Collectors.toUnmodifiableList());
What happens if another thread tries to add to result?

Accepted Answer

UnsupportedOperationException at runtime.. B is correct because `Collectors.toUnmodifiableList()` returns an unmodifiable list, and any attempt to modify it (e.g., via `add()`) throws an `UnsupportedOperationException`. The stream pipeline itself is safe and compiles fine; the issue is the mutability of the resulting collection.

Answer

Compilation error because var cannot be used with streams.

Answer

The thread successfully adds the element.

Answer

NullPointerException.