如何使用Java 8 Optionals在三个对象均存在时执行操作？

Great question! That nested ifPresent chain is definitely a readability nightmare—let’s look at a few idiomatic Java 8 approaches to clean this up while keeping things concise and maintainable.

Option 1: Chain with flatMap and map #

Instead of nesting ifPresent, you can use flatMap to chain the Optionals together, which keeps the logic in a single fluent chain without deep indentation:

maybeTarget.flatMap(target ->
    maybeSourceName.flatMap(sourceName ->
        maybeEventName.map(eventName -> {
            sendInvite(target.getEmail(), String.format("Hi %s, %s has invited you to %s", target.getName(), sourceName, eventName));
            return null; // Or return a value if sendInvite has a return type
        })
    )
);

This works because:

• flatMap expects an Optional as the return value, so we pass the next Optional chain
• map is used for the final operation since we don’t need to return another Optional after calling sendInvite

It’s still a bit nested, but far cleaner than the original ifPresent pyramid, and it stays true to Java 8’s functional style.

Option 2: Simple Conditional Check with a Helper Method #

Sometimes the most readable solution isn’t the most "functional" one. Extracting the logic into a helper method makes the intent crystal clear, and avoids any nested chains entirely:

// Helper method to encapsulate the invite logic
private void sendInviteIfAllPresent(Optional<User> maybeTarget, Optional<String> maybeSourceName, Optional<String> maybeEventName) {
    if (maybeTarget.isPresent() && maybeSourceName.isPresent() && maybeEventName.isPresent()) {
        User target = maybeTarget.get();
        String sourceName = maybeSourceName.get();
        String eventName = maybeEventName.get();
        sendInvite(target.getEmail(), String.format("Hi %s, %s has invited you to %s", target.getName(), sourceName, eventName));
    }
}

// Call it like this
sendInviteIfAllPresent(maybeTarget, maybeSourceName, maybeEventName);

This is straightforward, easy to debug, and anyone reading your code will immediately understand what’s happening. Don’t overcomplicate things with streams if a simple conditional works better!

Option 3: Use Stream to Filter and Collect (For More Scalable Cases) #

If you ever need to handle more than 3 Optionals, wrapping them in a Stream can scale nicely. Note that this requires some type casting (since the stream holds mixed types), so it’s best used when you have a larger number of Optionals:

import java.util.stream.Collectors;
import java.util.stream.Stream;

Stream.of(maybeTarget, maybeSourceName, maybeEventName)
      .filter(Optional::isPresent)
      .map(Optional::get)
      .collect(Collectors.collectingAndThen(Collectors.toList(), values -> {
          if (values.size() == 3) {
              User target = (User) values.get(0);
              String sourceName = (String) values.get(1);
              String eventName = (String) values.get(2);
              sendInvite(target.getEmail(), String.format("Hi %s, %s has invited you to %s", target.getName(), sourceName, eventName));
          }
          return null;
      }));

This approach is flexible, but the type casting makes it less ideal for small numbers of Optionals. Stick with the first two options for your specific case.

内容的提问来源于stack exchange，提问作者hughjdavey