所描述的行为可以通过使用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提供的一个非常小的例子(模式匹配，流也就是惰性评估列表，单体类型，不可变集合，…)

另一种选择是:

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

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

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

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

没有一个很好的方法可以打破常规。如果你想在常规的基础上使用更干净的语法，那么你可以创建一个实用工具类来帮助你:

public class OptionalEx {
    private boolean isPresent;

    private OptionalEx(boolean isPresent) {
        this.isPresent = isPresent;
    }

    public void orElse(Runnable runner) {
        if (!isPresent) {
            runner.run();
        }
    }

    public static <T> OptionalEx ifPresent(Optional<T> opt, Consumer<? super T> consumer) {
        if (opt.isPresent()) {
            consumer.accept(opt.get());
            return new OptionalEx(true);
        }
        return new OptionalEx(false);
    }
}

然后你可以在其他地方使用静态导入来获得与你想要的语法相近的语法:

import static com.example.OptionalEx.ifPresent;

ifPresent(opt, x -> System.out.println("found " + x))
    .orElse(() -> System.out.println("NOT FOUND"));

如果你只能使用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"));

对我来说，@Dane White的答案是OK的，首先我不喜欢使用Runnable，但我找不到任何替代品。

这里是我更喜欢的另一个实现:

public class OptionalConsumer<T> {
    private Optional<T> optional;

    private OptionalConsumer(Optional<T> optional) {
        this.optional = optional;
    }

    public static <T> OptionalConsumer<T> of(Optional<T> optional) {
        return new OptionalConsumer<>(optional);
    }

    public OptionalConsumer<T> ifPresent(Consumer<T> c) {
        optional.ifPresent(c);
        return this;
    }

    public OptionalConsumer<T> ifNotPresent(Runnable r) {
        if (!optional.isPresent()) {
            r.run();
        }
        return this;
    }
}

然后:

Optional<Any> o = Optional.of(...);
OptionalConsumer.of(o).ifPresent(s -> System.out.println("isPresent " + s))
                .ifNotPresent(() -> System.out.println("! isPresent"));

更新1:

上面的解决方案为传统的开发方式，当你有价值，想要处理它，但如果我想定义功能和执行将是然后，检查下面的增强;

public class OptionalConsumer<T> implements Consumer<Optional<T>> {
private final Consumer<T> c;
private final Runnable r;

public OptionalConsumer(Consumer<T> c, Runnable r) {
    super();
    this.c = c;
    this.r = r;
}

public static <T> OptionalConsumer<T> of(Consumer<T> c, Runnable r) {
    return new OptionalConsumer(c, r);
}

@Override
public void accept(Optional<T> t) {
    if (t.isPresent()) {
        c.accept(t.get());
    }
    else {
        r.run();
    }
}

Then可用作:

Consumer<Optional<Integer>> c = OptionalConsumer.of(
    System.out::println, 
    () -> System.out.println("Not fit")
);

IntStream.range(0, 100)
    .boxed()
    .map(i -> Optional.of(i)
    .filter(j -> j % 2 == 0))
    .forEach(c);

在这个新代码中，你有3个东西:

可以很容易地定义一个对象存在之前的功能。 没有为每个可选对象创建对象引用，只有一个，所以内存比GC更少。 它正在实现消费者，以便更好地与其他组件一起使用。

顺便说一下，现在它的名字更有描述性它实际上是Consumer<Optional<?>>

假设你有一个列表，并且避免了isPresent()问题(与可选项相关)，你可以使用.iterator(). hasnext()来检查是否不存在。