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

Question 1

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?

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

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 2

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 3

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 4

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 5

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.

Question 6

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

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

Accepted Answer

IOException: Checked. Checked exceptions must be handled or declared; unchecked extend RuntimeException.

Answer

ArrayIndexOutOfBoundsException: Checked

Answer

IllegalArgumentException: Checked

Question 8

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

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.. 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 10

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.. 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 11

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

Accepted Answer

Consumer. A lambda that takes a String and returns nothing matches the `Consumer` functional interface, which has a single abstract method `void accept(String t)`. `Consumer` is designed for operations that consume an input and produce no output, such as printing or logging the string.

Answer

Predicate<String>

Answer

Function<String, Void>

Answer

Supplier<String>

Question 12

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

Accepted Answer

IntStream.generate(() -> new Random().nextInt()). `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 13

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.. `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 14

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

Accepted Answer

B and D both produce Optional.. Option A is correct because it states that options B and D both produce Optional. Option B uses list.stream().collect(Collectors.maxBy(Integer::compareTo)), which returns an Optional containing the maximum element. Option D uses list.stream().max(Integer::compareTo), which also returns an Optional with the maximum element. Option C, list.stream().max() without arguments, fails to compile because the Stream.max() method requires a Comparator. Therefore, A is the correct choice.

Answer

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

Answer

list.stream().max()

Answer

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

Question 15

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

Accepted Answer

Both B and C.. Option A, 'Both B and C,' is the correct answer because both statements accurately describe the result. Collectors.groupingBy with Function.identity() and Collectors.counting() produces a Map (where T is the element type) containing the frequency of each element, which can also be described as a Map with occurrence counts. Options B and C individually are true but incomplete; the question expects selection of the combination. Option D is incorrect because groupingBy without a 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.