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

Question 1

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.

Question 2

Which TWO of the following are terminal operations on a stream? (Choose two.)

Accepted Answer

forEach. `forEach` is a terminal operation that consumes the stream, applying the provided action to each element and producing a side effect without returning a new stream. Option C is correct because `reduce` is a terminal operation that combines stream elements into a single result using an associative accumulation function, terminating the stream pipeline.

Answer

distinct

Answer

filter

Answer

map

Question 3

Which TWO statements about method references are true? (Choose two.)

Accepted Answer

Constructor references use the syntax Class::new.. Constructor references use the syntax `Class::new` to refer to a constructor of a class, which can be used with a functional interface whose method matches the constructor's signature. This allows creating instances without explicitly invoking `new`, leveraging the same target type inference as lambda expressions.

Answer

Array constructor references are not supported.

Answer

Instance method references always use the keyword static.

Answer

Method references cannot refer to methods declared in the same class.

Question 4

Which THREE of the following are valid ways to create an infinite stream? (Choose three.)

Accepted Answer

IntStream.generate(() -> 0). `IntStream.generate(() -> 0)` uses a supplier that always returns 0, producing an infinite stream of zeros. The `generate` method creates an unordered infinite stream by repeatedly invoking the supplier, with no termination condition.

Answer

IntStream.range(0, Integer.MAX_VALUE)

Answer

Stream.of(1,2,3)

Question 5

What is the result of executing this code?

Accepted Answer

An exception is thrown at runtime.. The code attempts to call `findFirst()` on a `Stream<String>` that has already been consumed by a previous terminal operation (`forEach`). In Java, streams are single-use; after a terminal operation is executed, the stream is closed and cannot be reused. Any attempt to perform another terminal operation on the same stream throws an `IllegalStateException` at runtime.

Answer

bbc

Answer

Compilation error

Answer

baaabc

Question 6

What is the output of the following code?
```java
System.out.println(Stream.of(1, 2).map(i -> i * 2.0).count());
```

Accepted Answer

2. The code is:
```java
System.out.println(Stream.of(1, 2).map(i -> i * 2.0).count());
```
This creates a stream of integers 1 and 2, maps each to a Double (2.0 and 4.0), and then calls count() which returns the number of elements in the stream, which is 2. count() returns a long, but when printed, it outputs 2 (not 2.0). Option C is correct because the stream has two elements.

Answer

2.0

Answer

1

Answer

Compilation error

Question 7

A team implements a stream pipeline that processes a large dataset in parallel. They use a stateful lambda expression inside the map operation to maintain a count. What is the most likely outcome?

Accepted Answer

The pipeline will produce non-deterministic results due to race conditions.. Using a stateful lambda (one that mutates shared mutable state) inside a parallel stream's map operation introduces race conditions. The map operation is intended to be stateless and non-interfering; when multiple threads concurrently update a shared counter without proper synchronization, the result becomes non-deterministic and unpredictable.

Answer

The pipeline will produce correct results if the stateful lambda is synchronized.

Answer

The pipeline will throw a ConcurrentModificationException.

Answer

The pipeline will always produce the same result regardless of parallelism.

Question 8

A developer writes a stream pipeline that uses flatMap and filter but notices that the intermediate streams created by flatMap are never garbage-collected early, causing memory pressure. What is the most effective optimization to reduce memory usage?

Accepted Answer

Move the filter operation before the flatMap operation.. Moving the filter operation before flatMap reduces the number of elements passed to flatMap, thereby reducing the number of intermediate streams created and their memory footprint. Streams are lazy, so filter applied early discards unwanted elements before flatMap ever sees them, which directly lowers memory pressure from intermediate stream objects.

Answer

Replace flatMap with map and collect into a list.

Answer

Use a terminal operation like collect with a custom collector to process elements eagerly.

Answer

Use a parallel stream to process elements concurrently.

Question 9

A method returns an Optional<String>. The developer wants to transform the value inside the Optional to uppercase and print it, but only if present. Which best-practice approach uses streams?

Accepted Answer

opt.stream().map(String::toUpperCase).forEach(System.out::println);. It converts the Optional to a Stream using opt.stream(), then applies map(String::toUpperCase) to transform the value, and finally uses forEach(System.out::println) to print it only if present. This approach leverages the Stream API's lazy evaluation and functional pipeline, which is the best practice for integrating Optional with streams.

Answer

opt.map(String::toUpperCase).ifPresent(System.out::println);

Answer

opt.ifPresent(s -> System.out.println(s.toUpperCase()));

Answer

Stream.of(opt).map(o -> o.get().toUpperCase()).forEach(System.out::println);

Question 10

Which TWO are valid ways to obtain a Stream from a List<String> named 'list'? (Choose two.)

Accepted Answer

list.stream(). Options A and E are correct. The `List` interface provides the `stream()` method to obtain a sequential stream and `parallelStream()` to obtain a parallel stream. Option B is incorrect because `Stream.of(list)` treats the list itself as a single element, producing a `Stream>` rather than a `Stream`. Option C is incorrect because `Arrays.stream(list.toArray())` would work if you had a String array, but it returns a `Stream

Answer

Stream.of(list)

Answer

Arrays.stream(list.toArray())

Answer

new Stream<>(list)

Question 11

Which are valid method references in Java 17?

Accepted Answer

String::new. A is a constructor reference, a valid type of method reference. B is a reference to an instance method of an arbitrary object of type String. D is a reference to a static method. E is a reference to an instance method of the current object, valid in an instance context. C is invalid because null cannot be a qualifier.

Answer

null::equals

Question 12

Which TWO are terminal operations on the Stream interface? (Choose two.)

Accepted Answer

count(). A is correct because `count()` is a terminal operation that reduces the stream to a single `long` value by counting the number of elements after processing the pipeline. It triggers the stream pipeline execution and consumes the stream, making it a terminal operation per the `Stream` interface specification.

Answer

filter()

Answer

map()

Answer

sorted()

Question 13

What is the output of the code above?

Accepted Answer

18. The code creates a stream of lists containing numbers 1 through 9, flatMaps to a single stream of integers, filters for numbers divisible by 3 (leaving 3, 6, 9), and reduces them by summing. The sum is 3+6+9=18, making option A correct.

Answer

15

Answer

9

Answer

27