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

Question 1

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

Accepted Answer

reduce. Option C, reduce, is a terminal operation because it consumes the stream's elements and produces a single combined result (such as a sum or concatenation), triggering the pipeline's execution. Option D, forEach, is terminal since it iterates over each element to perform a side effect and returns void, closing the stream. Option E, collect, is terminal because it gathers the stream's elements into a mutable result container like a List or Set via a Collector, ending the stream pipeline. Options A (filter) and B (map) are not terminal; they are intermediate operations that return a new Stream and are lazy, only executing when a terminal operation is invoked.

Answer

filter

Answer

map

Question 2

A team is implementing a parallel stream to process a large dataset. They notice that the operation is slower than expected. Which change is most likely to improve performance?

Accepted Answer

Ensure the stream source is an ArrayList and the operation is stateless and associative.. Parallel stream performance depends on the stream source being efficiently splittable (like an ArrayList, which has O(1) random access and can be split evenly) and the operation being stateless and associative to avoid synchronization overhead and ensure correct results. A poorly splittable source (e.g., LinkedList) or stateful operations can cause contention and reduce parallelism gains.

Answer

Use a sequential stream.

Answer

Use a custom Collector instead of reduce.

Answer

Increase the parallelism level by setting -Djava.util.concurrent.ForkJoinPool.common.parallelism=100.

Question 3

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

Accepted Answer

The 'reduce()' operation can produce a result of a different type than the stream elements.. The `reduce()` operation in the Stream API uses a combiner function that can transform the stream elements into an accumulated result of a different type. For example, `stream.reduce(0, (sum, i) -> sum + i, Integer::sum)` returns an `Integer` from an `IntStream`, or you can reduce a `Stream` to a `StringBuilder`. This is explicitly allowed by the `reduce(U identity, BiFunction accumulator, BinaryOperator combiner)` signature.

Answer

The 'flatMap()' operation is a terminal operation.

Answer

The 'collect()' operation is an intermediate operation.

Answer

Streams can be reused after a terminal operation.

Question 4

Refer to the exhibit. A developer runs the code and gets an IllegalStateException on the second forEach. Which statement explains why?

Accepted Answer

The stream has already been operated upon or closed.. A Stream in Java cannot be reused after a terminal operation has been executed. Once the first forEach terminal operation completes, the stream is consumed and closed. Attempting to call another terminal operation (the second forEach) on the same stream reference throws an IllegalStateException with the message 'stream has already been operated upon or closed'.

Answer

The filter operation is not lazy.

Answer

The map operation modifies the source list.

Answer

The stream is not closed after the first terminal operation.

Question 5

Refer to the exhibit. What is the output?

```java
import java.util.stream.IntStream;

public class Example {
    public static void main(String[] args) {
        int sum = IntStream.rangeClosed(0, 5)
                .filter(i -> i >= 0)
                .sum();
        System.out.println(sum);
    }
}
```

Accepted Answer

15. The stream pipeline starts with `IntStream.rangeClosed(0, 5)` producing the integers 0, 1, 2, 3, 4, 5. The filter passes all these values, and the map is an identity function (or absent). The reduction sums them: 0+1+2+3+4+5 = 15. Therefore, the output is 15.

Answer

0

Answer

10

Answer

5

Question 6

Refer to the exhibit. What is the output?

Accepted Answer

{3=[Bob], 5=[Alice, David], 7=[Charlie]}. The code groups names by the length of their string using `Collectors.groupingBy(String::length, Collectors.toList())`. The names "Alice" and "David" have length 5, "Bob" has length 3, and "Charlie" has length 7. The resulting map has keys 3, 5, and 7. Although `groupingBy` returns a `HashMap` without guaranteed order, the expected output in this context displays the keys in ascending numerical order: 3, 5, 7. Therefore, option C correctly shows the groups in that order with the corresponding names. Option B is incorrect because it lists the keys in non-ascending order (5, 3, 7), which does not match the typical output format.

Answer

{3=[Bob], 5=[Alice, David, Charlie]}

Answer

{5=[Alice, David], 3=[Bob], 7=[Charlie]}

Answer

{3=[Bob], 5=[Alice], 7=[Charlie, David]}

Question 7

A developer writes the following code to partition a list of integers into even and odd numbers, then print the count of each group: import java.util.*; import java.util.stream.*; public class PartitionExample { public static void main(String[] args) { List numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); Map> partitioned = numbers.stream() .collect(Collectors.partitioningBy(n -> n % 2 == 0)); System.out.println(partitioned.get(true).size() + " " + partitioned.get(false).size()); } } What is the output?

Accepted Answer

5 5. The partitioningBy collector splits elements into two groups based on a predicate: true and false. It always includes both keys, even if one group is empty. With the list 1 to 10, there are five even and five odd numbers. The code retrieves the sizes of both lists and prints them separated by a space, yielding '5 5'.

Answer

4 5

Answer

5 4

Answer

Compilation fails because partitioningBy requires a downstream collector.

Question 8

A logistics company uses a Stream of shipment tracking codes. A developer writes: Stream codes = Stream.of("AB12", "CD34", "EF56"); Map> result = codes.collect(Collectors.partitioningBy(c -> c.startsWith("A"))); What is the value of result.get(false) after execution?

Accepted Answer

[CD34, EF56]. partitioningBy returns a Map with exactly two entries, one for true and one for false, each holding a List of matching elements. Since CD34 and EF56 do not start with "A", they land in the false partition, preserving encounter order. The true partition holds AB12, so result.get(false) yields the two non-matching codes.

Answer

[AB12, CD34, EF56]

Answer

[AB12]

Answer

null

Question 9

A financial application processes a Stream of transaction amounts. A developer writes: Optional total = amounts.reduce((a, b) -> a + b); If the stream is empty, what happens when the developer calls total.orElseThrow()?

Accepted Answer

A NoSuchElementException is thrown.. The single-argument reduce returns an Optional because an empty stream has no result and no identity to fall back on. For an empty stream the Optional is empty, and orElseThrow() translates that emptiness into a NoSuchElementException. To avoid this, supply an identity with the two-argument reduce or handle the empty case explicitly.

Answer

An IllegalStateException is thrown.

Answer

null is returned.

Answer

The value 0 is returned.

Question 10

A developer is writing a method that takes a List<String> named names and must return a single String consisting of the names joined by a comma, where null elements are replaced with the literal text "UNKNOWN". The developer writes:

String result = names.stream()
    .map(n -> n == null ? "UNKNOWN" : n)
    .collect(Collectors.joining(","));

Which statement about this code is true?

Accepted Answer

It compiles and produces the expected joined string because Collectors.joining concatenates the mapped stream elements with the given delimiter.. The map operation replaces each null with the literal "UNKNOWN" before the collector runs, so Collectors.joining receives a stream of non-null strings and concatenates them with commas. The single-argument joining collector is valid and needs no prior toList. The pipeline both compiles and produces the expected comma-separated output.

Answer

It compiles but always returns an empty string because the delimiter argument is ignored when the stream contains more than one element.

Answer

It throws a NullPointerException at runtime because Collectors.joining does not accept null elements in the stream.

Answer

It fails to compile because Collectors.joining requires a Collectors.toList() call before it can be used with a delimiter.

Question 11

A developer is writing a method that groups employees by department and then, for each department, computes the total salary. The code is:

Map<String, Double> totals = employees.stream()
    .collect(Collectors.groupingBy(Employee::getDepartment,
        Collectors.summingDouble(Employee::getSalary)));

Which statement best describes the type of the values in the resulting map and why?

Accepted Answer

The values are Double because the downstream collector summingDouble accumulates salary as a double.. The two-argument groupingBy overload takes a classifier and a downstream collector. The downstream collector summingDouble(Employee::getSalary) produces a Double result, and groupingBy stores that result as the map value. Therefore the result is Map<String, Double>, matching the declared variable. The other options incorrectly claim primitive, OptionalDouble, or Number value types, none of which match the collector's actual finisher type.

Answer

The values are Number because summingDouble is a generic collector that returns a Number to support both int and double salaries.

Answer

The values are double because the map stores primitive double values to avoid boxing.

Answer

The values are OptionalDouble because summingDouble wraps the result in an OptionalDouble to handle empty groups.

Question 12

A developer is writing a method that takes a `java.util.List<String>` and returns a single comma-separated String of all elements in uppercase. The method must be implemented as a single stream pipeline using `Collectors.joining`. Which pipeline correctly produces the required result?

Accepted Answer

list.stream().map(String::toUpperCase).collect(Collectors.joining(",")). The joining collector with a delimiter is specifically designed to concatenate stream elements into a single String with separators. Combining map(String::toUpperCase) with Collectors.joining(",") transforms each element and inserts commas between them, producing the exact format required. The other options either omit the delimiter, misuse the joining overloads, or use reduce incorrectly, so they do not satisfy the method's contract.

Answer

list.stream().map(String::toUpperCase).collect(Collectors.joining())

Answer

list.stream().collect(Collectors.joining(",", String::toUpperCase, String::toUpperCase))

Answer

list.stream().map(String::toUpperCase).reduce(",", String::concat)

Question 13

A developer has a Stream<String> named words and writes the following pipeline:

String out = words
    .filter(w -> w.length() > 3)
    .findFirst()
    .orElse("none");

Later the same Stream reference words is passed to a second pipeline. What is the result?

Accepted Answer

The second pipeline throws IllegalStateException because a stream cannot be reused after a terminal operation has been invoked on it.. A Stream instance is consumed by its terminal operation and cannot be reused. Calling a second pipeline on the same reference triggers IllegalStateException when that pipeline's terminal operation runs. The fix is to obtain a fresh stream, for example by calling words' source collection's stream method again or by using a Supplier>.

Answer

The second pipeline compiles but returns an empty Optional because the stream is automatically reset to its initial state.

Answer

The second pipeline only fails if it is a parallel stream; sequential streams may be reused any number of times.

Answer

The second pipeline executes normally and re-reads the original source because Stream is backed by the collection and can be re-traversed.

Question 14

A developer writes the following pipeline to find the first even number greater than 100 in an infinite stream:

Optional<Integer> result = Stream.iterate(1, n -> n + 1)
    .filter(n -> n % 2 == 0 && n > 100)
    .findFirst();

What happens when this code runs?

Accepted Answer

It returns Optional.of(102) because findFirst short-circuits the infinite stream once the filter matches.. Stream.iterate with a seed and unary operator produces an infinite sequential ordered stream. Because filter is lazy and findFirst is a short-circuiting terminal operation, the pipeline evaluates elements on demand and stops at the first match. The first even number greater than 100 is 102, so the result is Optional.of(102). The other options incorrectly claim hanging, an exception, or a bounded prefix, none of which apply when a short-circuiting operation is present.

Answer

It returns Optional.empty() because findFirst only examines a bounded prefix of the stream by default.

Answer

It hangs indefinitely because Stream.iterate creates an infinite stream and findFirst cannot determine when to stop.

Answer

It throws IllegalStateException because an infinite stream cannot be used with a terminal operation.

Question 15

A developer has a Stream<String> of city names and writes the following pipeline:

long count = cities.filter(c -> c.length() > 5).count();

Which statement best describes the nature of the count() operation in this pipeline?

Accepted Answer

count() is a terminal operation that triggers processing of the stream.. count() is a terminal operation that returns the number of elements in the stream as a long. It forces evaluation of the lazy filter intermediate operation and consumes the stream. Because the stream is consumed, it cannot be reused; a new stream must be created from the source to perform additional processing.

Answer

count() can be called multiple times on the same stream without error.

Answer

count() is a lazy operation that does not process elements until another operation follows.

Answer

count() is an intermediate operation that returns a new Stream.