也许我忽略了一些东西，但是有什么原因不能使用Optional#map吗？
下面的示例不打印任何内容，因为Optional是 short-circuiting，即如果Optional中的值不存在（它是null或Optional为空），它将被视为空。

Optional.ofNullable("test")
        .map(s -> null)
        .ifPresent(System.out::println);

因此，我认为您可以执行以下操作：

return Optional.ofNullable(thing)
               .map(x -> x.nullableMethod1(a))
               .map(y -> y.nullableMethod2(b))
               .map(Z::nullableMethod3);

这将Map您的thing（如果存在），否则返回空的Optional。

在Java 8中，Elvis运算符可以通过将.map(...)调用链接到Optional.ofNullable(...)上并使用.orElse(...)对其进行封顶来模拟：

Optional.ofNullable(dataObject)
.map(DataObject::getNestedDataObject)
.map(NestedDataObject::getEvenMoreNestedDataObject)
...
.orElse(null);

一个完整的例子：

import java.util.Optional;

class Main {
  // Data classes:
  static class Animal {
    Leg leg;

    Animal(Leg leg) {
      this.leg = leg;
    }

    Leg getLeg(){return this.leg;}

    public String toString(){
      String out = "This is an animal";
      out += leg != null ? " with a leg" : "";
      return out;
    }
  }

  static class Leg {
    Toes toes;

    Leg(Toes toes) {
      this.toes = toes;
    }

    Toes getToes(){return this.toes;}

    public String toString(){
      String out = "This is a leg";
      out += toes != null ? " with a collection of toes" : "";
      return out;
    }
  }

  static class Toes {
    Integer numToes;

    Toes(Integer numToes) {
      this.numToes = numToes;
    }

    Integer getNumToes(){return this.numToes;}

    public String toString(){
      String out = "This is a collection of ";
      out += numToes != null && numToes > 0 ? numToes : "no";
      out += " toes";
      return out;
    }
  }

  // A few example Elvis operators:
  static Integer getNumToesOrNull(Animal a) {
    return Optional.ofNullable(a)
      .map(Animal::getLeg)
      .map(Leg::getToes)
      .map(Toes::getNumToes)
      .orElse(null);
  }

  static Toes getToesOrNull(Animal a) {
    return Optional.ofNullable(a)
      .map(Animal::getLeg)
      .map(Leg::getToes)
      .orElse(null);
  }

  static Leg getLegOrNull(Animal a) {
    return Optional.ofNullable(a)
      .map(Animal::getLeg)
      .orElse(null);
  }

  // Main function:
  public static void main(String[] args) {
    // Trying to access 'numToes':
    System.out.println(getNumToesOrNull(new Animal(new Leg(new Toes(4))))); // 4
    System.out.println(getNumToesOrNull(new Animal(new Leg(new Toes(null))))); // null
    System.out.println(getNumToesOrNull(new Animal(new Leg(null)))); // null
    System.out.println(getNumToesOrNull(new Animal(null))); // null
    System.out.println(getNumToesOrNull(null)); // null

    // Trying to access 'toes':
    System.out.println(getToesOrNull(new Animal(new Leg(new Toes(4))))); // This is a collection of 4 toes
    System.out.println(getToesOrNull(new Animal(new Leg(new Toes(null))))); // This is a collection of no toes
    System.out.println(getToesOrNull(new Animal(new Leg(null)))); // null
    System.out.println(getToesOrNull(new Animal(null))); // null
    System.out.println(getToesOrNull(null)); // null

    // Trying to access 'leg':
    System.out.println(getLegOrNull(new Animal(new Leg(new Toes(4))))); // This is a leg with a collection of toes
    System.out.println(getLegOrNull(new Animal(new Leg(new Toes(null))))); // This is a leg with a collection of toes
    System.out.println(getLegOrNull(new Animal(new Leg(null)))); // This is a leg
    System.out.println(getLegOrNull(new Animal(null))); // null
    System.out.println(getLegOrNull(null)); // null
  }
}

我写了一个compiler plugin，它在编译时操纵AST生成Optional.ofNullable链
它几乎没有限制，但确实减少了重复代码
PS：我是作者的插件

模拟elvis操作员的另一个选项是使用以下帮助器函数：

public static <T> T get(final Supplier<T> it) {
    try {
        return it.get();
    } catch (final NullPointerException e) {
        return null;
    }
}

您可以像这样使用它：

var x = get(() -> thing.nullableMethod1(a).nullableMethod2(b).nullableMethod3());

为了完成Jacob的想法，我创建了这个类：

public class OptionalUtils {
  public static <T, U> Optional<U> elvisOperator(T t, Function<? super T, ? extends U> mapper) {
    return elvisOperator(Optional.ofNullable(t), mapper);
  }

  public static <T, U> Optional<U> elvisOperator(Optional<T> optional, Function<? super T, ? extends U> mapper) {
    return optional.flatMap(t -> Optional.ofNullable(mapper.apply(t)));
  }
}

那你就做

elvisOperator(elvisOperator(dataObject, DataObject::getNestedDataObject)
    NestedDataObject::getEvenMoreNestedDataObject))...