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

Question 1

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 2

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 3

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 4

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 5

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

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 7

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

Accepted Answer

forEach. forEach (A) is a terminal operation because it consumes each element of the stream and returns void, triggering the pipeline's execution and closing the stream. reduce (C) is also terminal: it performs a reduction on the stream's elements (e.g., using an identity and BinaryOperator or an Optional-returning variant) and produces a single result, thereby ending the stream. By contrast, distinct (B), filter (D), and map (E) are intermediate operations—they return a new lazy stream and only build up the pipeline, so they do not execute it or produce a final result on their own.

Answer

distinct

Answer

filter

Answer

map

Question 8

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

Accepted Answer

Constructor references use the syntax Class::new.. Option A is correct because constructor references in Java use the exact syntax ClassName::new (e.g., Supplier s = Foo::new;), which is a valid shorthand for a lambda that invokes the constructor. Option D is correct because a method reference is essentially a more concise form of a lambda expression, so it can be assigned to any compatible functional interface target type, provided the referenced method's signature matches the single abstract method. Option B is false because array constructor references are supported using the syntax Type[]::new (e.g., IntFunction f = int[]::new;). Option C is false because instance method references use the form instance::method or ClassName::instanceMethod, and do not require the static keyword. Option E is false because method references can freely refer to methods declared in the same class, such as this::helper or ClassName::helper.

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 9

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 10

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 11

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

Accepted Answer

list.stream(). Option A, list.stream(), is correct because Collection (and thus List) defines the default method stream() that returns a sequential Stream of the list's elements. Option E, list.parallelStream(), is also correct because Collection defines parallelStream(), which returns a possibly parallel Stream backed by the list. Option B, Stream.of(list), is wrong because it creates a Stream> containing the list as a single element, not a Stream. Option C, Arrays.stream(list.toArray()), is wrong because list.toArray() returns Object[], so Arrays.stream yields a Stream

Answer

Stream.of(list)

Answer

Arrays.stream(list.toArray())

Answer

new Stream<>(list)

Question 12

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

Accepted Answer

count(). Option A, count(), is a terminal operation because it triggers the stream pipeline to execute and returns a long result (the number of elements), consuming the stream so it cannot be reused. Option B, forEach(), is also terminal: it accepts a Consumer and performs an action on each element, causing the pipeline to run and rendering the stream consumed. By contrast, filter(), map(), and sorted() are intermediate operations—they return a new Stream (or a specialized stream) and are lazy, merely building up the pipeline until a terminal operation is invoked. Therefore C, D, and E do not belong among the terminal operations.

Answer

filter()

Answer

map()

Answer

sorted()

Question 13

Assuming the code runs in a multithreaded environment, which statement best describes the behavior?

Accepted Answer

It prints the doubled numbers in a non-deterministic order and results may contain missing or duplicate entries.. Using a parallel stream with a stateful lambda (e.g., modifying an external `results` list inside `peek` or `forEach`) introduces data races and non-deterministic behavior. The `peek` operation is not synchronized, so the order of printed doubled numbers is unpredictable, and concurrent modifications to the shared `results` list can cause missing or duplicate entries due to race conditions.

Answer

The code will compile but throw an exception at runtime because of the use of parallel stream with stateful lambda.

Answer

It prints the doubled numbers in order (2, 4, 6, 8) and results contains [1,2,3,4] in that order.

Answer

It may produce a ConcurrentModificationException because results is modified while iterating.

Question 14

A developer needs to concatenate two Stream<String> into one. Which approach is most idiomatic?

Accepted Answer

Stream.concat(stream1, stream2). `Stream.concat(stream1, stream2)` is the idiomatic, built-in static method in the Java Stream API for concatenating two streams into a single sequential stream. It creates a lazily concatenated stream whose elements are all the elements of the first stream followed by all the elements of the second stream, preserving encounter order.

Answer

stream1.flatMap(s -> stream2)

Answer

new StreamBuilder().add(stream1).add(stream2).build()

Answer

stream1.merge(stream2)

Question 15

A stream pipeline uses the peek method for debugging. Which statement about peek is correct?

Accepted Answer

peek is an intermediate operation used for debugging; it is not suitable for production side effects.. The `peek` method is an intermediate operation in the Stream API, designed primarily for debugging to observe elements as they flow through the pipeline. It is not intended for production side effects because its execution is not guaranteed for every element (e.g., due to short-circuiting or optimization), and relying on it for stateful operations can lead to unpredictable behavior.

Answer

peek is a terminal operation that prints elements.

Answer

peek can only be used with parallel streams.

Answer

peek is an intermediate operation, and it is guaranteed to be executed for each element.