OCP Streams and Lambda Expressions Questions and Answers

Question 1

Which of the following best describes the core difference between intermediate and terminal operations in the Java Stream API?

Accepted Answer

Intermediate operations are lazy and return a new stream, while terminal operations are eager and produce a result or side-effect.

Answer

Intermediate operations are optional, while every stream pipeline must end with a terminal operation.

Answer

Intermediate operations, like `map()` and `filter()`, can only be chained once, whereas terminal operations can be chained multiple times.

Answer

Terminal operations can only be applied to parallel streams, while intermediate operations work for both sequential and parallel streams.

Question 2

A developer is working with a `Stream` and wants to produce a `Map>` where the keys are the lengths of the strings and the values are lists of strings of that length. Which `Collector` should be used?

Accepted Answer

Collectors.groupingBy(String::length)

Answer

Collectors.toMap(String::length, s -> s)

Answer

Collectors.partitioningBy(s -> s.length() > 0)

Answer

Collectors.toMap(s -> s.length(), s -> List.of(s), (list1, list2) -> list1)

Question 3

Given the following code snippet, what is the output? ```java List list = Arrays.asList("a", "b", "c"); Optional result = list.stream() .filter(s -> s.equals("d")) .findFirst(); System.out.println(result.orElse("Not Found")); ```

Accepted Answer

Not Found

Answer

An empty Optional

Answer

null

Answer

A NoSuchElementException is thrown

Question 4

Why would a developer choose to use a primitive stream like `IntStream` over a `Stream<Integer>`?

Accepted Answer

To improve performance by avoiding the overhead of boxing and unboxing primitive values into wrapper objects.

Answer

To gain access to more powerful terminal operations like `collect()`.

Answer

Because `IntStream` can handle a larger range of integer values than `Stream<Integer>`.

Answer

Because primitive streams are the only way to perform parallel processing on numeric data.

Question 5

Which of the following is a valid and most concise lambda expression for a `java.util.function.Predicate<String>` that tests if a string is empty?

Accepted Answer

String::isEmpty

Answer

(String s) -> { return s.isEmpty(); }

Answer

s -> s.isEmpty()

Answer

() -> "".isEmpty()

Question 6

What is the result of the following stream pipeline?

```java
long count = Stream.of("apple", "banana", "apricot", "cherry")
                   .filter(s -> s.startsWith("a"))
                   .peek(System.out::println)
                   .count();
```

Accepted Answer

The code will print "apple" and "apricot", and `count` will be 2.

Answer

The code will not compile because `peek` is a terminal operation.

Answer

The code will print "apple", "banana", "apricot", and "cherry", and `count` will be 4.

Answer

The code will print nothing, and `count` will be 2.