DEV Community

Nicolas Frankel

Posted on • Originally published at blog.frankel.ch

Optional.stream()

This week, I learned about a nifty "new" feature of `Optional` that I want to share in this post. It's available since Java 9, so its novelty is relative.

Let's start with the following sequence to compute the total price of an order:

``````public BigDecimal getOrderPrice(Long orderId) {
List<OrderLine> lines = orderRepository.findByOrderId(orderId);
BigDecimal price = BigDecimal.ZERO;       // 1
for (OrderLine line : lines) {
price = price.add(line.getPrice());   // 2
}
return price;
}
``````
1. Provide an accumulator variable for the price
2. Add each line's price to the total price

Nowadays, it's probably more adequate to use streams instead of iterations. The following snippet is the equivalent to the previous one:

``````public BigDecimal getOrderPrice(Long orderId) {
List<OrderLine> lines = orderRepository.findByOrderId(orderId);
return lines.stream()
.map(OrderLine::getPrice)
.reduce(BigDecimal.ZERO, BigDecimal::add);
}
``````

Let's focus on the `orderId` variable: it may be `null`.

The imperative way to handle `null` values is to check it at the beginning of the method - and eventually throw:

``````public BigDecimal getOrderPrice(Long orderId) {
if (orderId == null) {
throw new IllegalArgumentException("Order ID cannot be null");
}
List<OrderLine> lines = orderRepository.findByOrderId(orderId);
return lines.stream()
.map(OrderLine::getPrice)
.reduce(BigDecimal.ZERO, BigDecimal::add);
}
``````

The functional way is to wrap the `orderId` in an `Optional`. This is what the code looks like using `Optional`:

``````public BigDecimal getOrderPrice(Long orderId) {
return Optional.ofNullable(orderId)                   // 1
.map(orderRepository::findByOrderId)          // 2
.flatMap(lines -> {                           // 3
BigDecimal sum = lines.stream()
.map(OrderLine::getPrice)
.reduce(BigDecimal.ZERO, BigDecimal::add);
return Optional.of(sum);                  // 4
}).orElse(BigDecimal.ZERO);                   // 5
}
``````
1. Wrap the `orderId` in an `Optional`
2. Find relevant order lines
3. Use `flatMap()` to get an `Optional<BigDecimal>`; `map()` would get an `Optional<Optional<BigDecimal>>`
4. We need to wrap the result into an `Optional` to conform to the method signature
5. If the `Optional` doesn't contain a value, the sum is `0`

`Optional` makes the code less readable! I believe that readability should trump code style every single time.

Fortunately, `Optional` offers a `stream()` method (since Java 9). It allows to simplify the functional pipeline:

``````public BigDecimal getOrderPrice(Long orderId) {
return Optional.ofNullable(orderId)
.stream()
.map(orderRepository::findByOrderId)
.flatMap(Collection::stream)
.map(OrderLine::getPrice)
.reduce(BigDecimal.ZERO, BigDecimal::add);
}
``````

Here's the summary of the type at each line:

Snippet Type
`Optional.ofNullable(orderId)` `Optional<Long>`
`stream()` `Stream<Long>`
`map(orderRepository::findByOrderId)` `Stream<List<OrderLine>>`
`flatMap(Collection::stream)` `Stream<OrderLine>`
`map(OrderLine::getPrice)` `Stream<BigDecimal>`
`reduce(BigDecimal.ZERO, BigDecimal::add)` `BigDecimal`

Functional code doesn't necessarily mean readable code. With the last changes, I believe it's both.

To go further:

Originally published at A Java Geek on February21st 2021