In modern Java development, we often encounter scenarios where we need to prioritize one list over another based on certain conditions. A common approach might involve multiple if-else statements or nested null checks. However, by leveraging the power of Optional and streams, we can achieve this in a more elegant and concise manner. Let's explore a technique that combines Optional.ofNullable() with streams to create clean, readable code for list prioritization.

The Problem

Imagine you have two lists of items, where one list should take priority over the other if it's non-empty. In our example, we'll use a scenario from an e-commerce application where we have fixed-price offers and variable-price offers, with fixed-price offers taking precedence.

The Solution

Here's the key piece of code that elegantly solves this problem:

Optional<Offer> bestOffer = Optional.ofNullable(applicableOffers.get(DiscountFormat.FIXED))
    .orElse(applicableOffers.get(DiscountFormat.VARIABLE))
    .stream()
    .max(Comparator.comparing(Offer::getValue));

Let's break this down:

1. Optional.ofNullable(applicableOffers.get(DiscountFormat.FIXED)): This creates an Optional that will contain the list of fixed-price offers if it exists, or be empty if it doesn't.
2. .orElse(applicableOffers.get(DiscountFormat.VARIABLE)): If the Optional from step 1 is empty (i.e., there are no fixed-price offers), this provides the list of variable-price offers as a fallback.
3. .stream(): We create a stream from whichever list we ended up with (fixed or variable).
4. .max(Comparator.comparing(Offer::getValue)): We find the offer with the maximum value in the chosen list.

Why This Works

This technique works because Optional.ofNullable() allows us to handle the potential absence of the preferred list (fixed-price offers) gracefully. If that list is present, it's used; if not, we fall back to the secondary list (variable-price offers).

By chaining this with stream() and max(), we can find the best offer from the chosen list in a single, fluent operation.

Benefits

1. Conciseness: This approach allows us to prioritize lists and find the best item in just a few lines of code.
2. Readability: The code clearly expresses the intent of prioritizing one list over another.
3. Null safety: By using Optional, we avoid null pointer exceptions and explicitly handle the case where a list might be absent.
4. Flexibility: This pattern can be easily adapted to different scenarios with multiple levels of prioritization.