所描述的行为可以通过使用Vavr(以前称为Javaslang)来实现，Vavr是Java 8+的对象函数库，它实现了大多数Scala构造(Scala是一种表现力更强的语言，在JVM上构建了更丰富的类型系统)。它是一个非常好的库，可以添加到Java项目中来编写纯函数式代码。

Vavr提供了Option单子，它提供了使用Option类型的函数，例如:

折叠:在两种情况下映射选项的值(已定义/空) onEmpty:当选项为空时允许执行一个可运行对象 Peek:允许使用选项的值(当定义时)。 与可选相反，它也是可序列化的，这意味着你可以安全地使用它作为方法参数和实例成员。

选项遵循单子法则，不同于Java的可选“伪单子”，并提供了更丰富的API。当然，你也可以从Java的Optional(或其他方式)中实现:Option.ofOptional(javaOptional) -Vavr专注于互操作性。

看这个例子:

// AWESOME Vavr functional collections (immutable for the gread good :)
// fully convertible to Java's counterparts.
final Map<String, String> map = Map("key1", "value1", "key2", "value2");

final Option<String> opt = map.get("nonExistentKey"); // you're safe of null refs!
        
final String result = opt.fold(
        () -> "Not found!!!",                // Option is None
        val -> "Found the value: " + val     // Option is Some(val)
);

此外，所有Vavr类型都可以转换为Java对应的类型，例如:Optional javaOptional = opt.toJava()，非常简单:)当然，转换也存在于另一种方式:Option Option = Option. ofoptional (javaOptional)。

注意:Vavr提供了一个io.vavr.API类，其中有很多方便的静态方法=)

进一步的阅读

空引用，十亿美元的错误

注意:这只是Vavr提供的一个非常小的例子(模式匹配，流也就是惰性评估列表，单体类型，不可变集合，…)

如果你只能使用Java 8或更低版本:

1)如果你没有弹簧数据，到目前为止最好的方法是:

opt.<Runnable>map(param -> () -> System.out.println(param))
      .orElse(() -> System.out.println("no-param-specified"))
      .run();

现在我知道对某些人来说，它不是那么可读，甚至很难理解，但对我个人来说，它看起来还不错，我想不出另一种流畅的方法来处理这种情况。

2)如果你足够幸运，你可以使用弹簧数据，最好的方法是 可选# ifPresentOrElse:

Optionals.ifPresentOrElse(opt, System.out::println,
      () -> System.out.println("no-param-specified"));

如果你能使用Java 9，你绝对应该使用:

opt.ifPresentOrElse(System.out::println,
      () -> System.out.println("no-param-specified"));

如果你使用Java 9+，你可以使用ifPresentOrElse()方法:

opt.ifPresentOrElse(
   value -> System.out.println("Found: " + value),
   () -> System.out.println("Not found")
);

你不能在ifPresent之后调用orElse，原因是，orElse是在可选对象上调用的，而ifPresent返回void。所以实现的最好方法是ifpresenttorelse。 它可以是这样的:

op.ifPresentOrElse( 
            (value) 
                -> { System.out.println( 
                         "Value is present, its: "
                         + value); }, 
            () 
                -> { System.out.println( 
                         "Value is empty"); }); 

另一种选择是:

System.out.println(opt.map(o -> "Found")
                      .orElse("Not found"));

但我不认为它能提高可读性。

或者像Marko建议的那样，使用三元操作符:

System.out.println(opt.isPresent() ? "Found" : "Not found");

问题是:

optional
  .map(object -> {
    System.out.println("If present.");
    return null;
  })
  .orElseGet( () -> {
    System.out.println("If empty.");
    return null;
  });

map()是否将第一个函数返回的null转换为empty();然后返回empty()。当它返回empty()时，它提示调用第二个函数。注意，orElseGet()不会将第二个函数返回的null转换为empty()，因此它将返回null。

参见map()的实现:

public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent())
        return empty();
    else {
        return Optional.ofNullable(mapper.apply(value));
    }
}

和orElseGet()的实现:

public T orElseGet(Supplier<? extends T> other) {
    return value != null ? value : other.get();
}

因此执行时:

if optional.isPresent()，系统将打印if present。，则If为空。，表达式将求值为null。 if !optional.isPresent()，系统将打印if为空。，表达式将求值为null。

如果提供给map()的函数返回任何其他值-任何其他值-代码将如您所期望的那样工作，如果isPresent()则执行提供给map()的函数，如果!isPresent()则执行提供给orElseGet()的函数:

例如，这个:

optional
  .map(data -> {
    System.out.println("If present.");
    return 0;
  })
  .orElseGet( () -> {
    System.out.println("If empty.");
    return 0;
  });

当执行:

if optional.isPresent()，系统将打印if present。，表达式的值为0。 if !optional.isPresent()，系统将打印if为空。，表达式的值为0。

如果是你的特定情况，我建议你的insert和update方法返回持久化对象，或者持久化对象的id，或者类似有用的东西;然后你可以使用类似这样的代码:

final Object persist = optional
  .map(object -> {
    System.out.println("If present.");
    return update(object);
  })
  .orElseGet( () -> {
    System.out.println("If empty.");
    return insert(new Object());
  });