下面的例子将说明两者的区别:

String destroyTheWorld() {
  // destroy the world logic
  return "successfully destroyed the world";
}

Optional<String> opt = Optional.of("Save the world");

// we're dead
opt.orElse(destroyTheWorld());

// we're safe    
opt.orElseGet(() -> destroyTheWorld());

答案也会出现在文档中。

public T orElseGet(供应商<?延伸T>其他):

如果存在则返回该值，否则调用other并返回 调用的结果。

如果可选选项出现，则供应商将不会被调用。然而,

公共的，其他的

如果存在则返回值，否则返回other。

如果other是一个返回字符串的方法，它将被调用，但如果Optional存在，它的值将不会返回。

简短的回答:

不管option . ispresent()值是多少，orElse()都会调用给定的函数 orElseGet()只会在Optional.isPresent() == false时调用给定的函数

在实际代码中，当所需资源的获取成本很高时，可能需要考虑第二种方法。

// Always get heavy resource
getResource(resourceId).orElse(getHeavyResource()); 

// Get heavy resource when required.
getResource(resourceId).orElseGet(() -> getHeavyResource()) 

要了解更多细节，请考虑以下使用该函数的示例:

public Optional<String> findMyPhone(int phoneId)

差异如下:

                           X : buyNewExpensivePhone() called

+——————————————————————————————————————————————————————————————————+——————————————+
|           Optional.isPresent()                                   | true | false |
+——————————————————————————————————————————————————————————————————+——————————————+
| findMyPhone(int phoneId).orElse(buyNewExpensivePhone())          |   X  |   X   |
+——————————————————————————————————————————————————————————————————+——————————————+
| findMyPhone(int phoneId).orElseGet(() -> buyNewExpensivePhone()) |      |   X   |
+——————————————————————————————————————————————————————————————————+——————————————+

当optional.isPresent() == false时，两种方法之间没有区别。然而，当optional.isPresent() == true时，不管你是否需要，orElse()总是会调用后续函数。

最后，使用的测试用例如下:

结果:

------------- Scenario 1 - orElse() --------------------
  1.1. Optional.isPresent() == true (Redundant call)
    Going to a very far store to buy a new expensive phone
    Used phone: MyCheapPhone

  1.2. Optional.isPresent() == false
    Going to a very far store to buy a new expensive phone
    Used phone: NewExpensivePhone

------------- Scenario 2 - orElseGet() --------------------
  2.1. Optional.isPresent() == true
    Used phone: MyCheapPhone

  2.2. Optional.isPresent() == false
    Going to a very far store to buy a new expensive phone
    Used phone: NewExpensivePhone

代码:

public class TestOptional {
    public Optional<String> findMyPhone(int phoneId) {
        return phoneId == 10
                ? Optional.of("MyCheapPhone")
                : Optional.empty();
    }

    public String buyNewExpensivePhone() {
        System.out.println("\tGoing to a very far store to buy a new expensive phone");
        return "NewExpensivePhone";
    }


    public static void main(String[] args) {
        TestOptional test = new TestOptional();
        String phone;
        System.out.println("------------- Scenario 1 - orElse() --------------------");
        System.out.println("  1.1. Optional.isPresent() == true (Redundant call)");
        phone = test.findMyPhone(10).orElse(test.buyNewExpensivePhone());
        System.out.println("\tUsed phone: " + phone + "\n");

        System.out.println("  1.2. Optional.isPresent() == false");
        phone = test.findMyPhone(-1).orElse(test.buyNewExpensivePhone());
        System.out.println("\tUsed phone: " + phone + "\n");

        System.out.println("------------- Scenario 2 - orElseGet() --------------------");
        System.out.println("  2.1. Optional.isPresent() == true");
        // Can be written as test::buyNewExpensivePhone
        phone = test.findMyPhone(10).orElseGet(() -> test.buyNewExpensivePhone());
        System.out.println("\tUsed phone: " + phone + "\n");

        System.out.println("  2.2. Optional.isPresent() == false");
        phone = test.findMyPhone(-1).orElseGet(() -> test.buyNewExpensivePhone());
        System.out.println("\tUsed phone: " + phone + "\n");
    }
}

我来到这里是为了工藤提到的问题。

我在和别人分享我的经验。

orElse或orElseGet，这是一个问题:

static String B() {
    System.out.println("B()...");
    return "B";
}

public static void main(final String... args) {

    System.out.println(
        Optional.of("A").orElse(B()) // B()'s gonna be invoked anyway
    );

    System.out.println("----");

    System.out.println(
        Optional.of("A").orElseGet(() -> B()) // B() won't be invoked
    );
}

打印

B()...
A
----
A

orElse计算B()的值与optional的值相互依赖。因此，orElseGet是懒惰的。

下面的例子将说明两者的区别:

String destroyTheWorld() {
  // destroy the world logic
  return "successfully destroyed the world";
}

Optional<String> opt = Optional.of("Save the world");

// we're dead
opt.orElse(destroyTheWorld());

// we're safe    
opt.orElseGet(() -> destroyTheWorld());

答案也会出现在文档中。

public T orElseGet(供应商<?延伸T>其他):

如果存在则返回该值，否则调用other并返回 调用的结果。

如果可选选项出现，则供应商将不会被调用。然而,

公共的，其他的

如果存在则返回值，否则返回other。

如果other是一个返回字符串的方法，它将被调用，但如果Optional存在，它的值将不会返回。

首先，检查两个方法的声明。

1) OrElse:执行逻辑并将结果作为参数传递。

public T orElse(T other) {    
 return value != null ? value : other;
}

2) OrElseGet:如果optional中的value为空，则执行逻辑

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

关于上述声明的解释: 可选的参数。orElse "总是被执行，而不管可选对象的值(null, empty或with value)。在使用“可选”时，一定要考虑到上述几点。orElse”，否则使用“Optional”。“orElse”在以下情况下可能非常危险。

风险-1)日志问题:如果orElse内部的内容包含任何日志语句: 在这种情况下，您将每次都记录它。

Optional.of(getModel())
   .map(x -> {
      //some logic
   })
  .orElse(getDefaultAndLogError());
 
getDefaultAndLogError() {
  log.error("No Data found, Returning default");
  return defaultValue;
}

风险-2)性能问题:如果orElse中的内容是时间密集型的: 时间密集型内容可以是任何i/o操作DB调用，API调用，文件读取。如果将这些内容放在orElse()中，系统最终将执行无用的代码。

Optional.of(getModel())
   .map(x -> //some logic)
   .orElse(getDefaultFromDb());

getDefaultFromDb() {
   return dataBaseServe.getDefaultValue(); //api call, db call.
}

风险-3)非法状态或Bug问题:如果orElse内部的内容正在改变某些对象状态: 我们可能会在另一个地方使用相同的对象，比如在Optional内部。地图功能，它会让我们陷入一个严重的错误。

List<Model> list = new ArrayList<>();
Optional.of(getModel())
  .map(x -> {
  })
  .orElse(get(list));

get(List < String > list) {
   log.error("No Data found, Returning default");
   list.add(defaultValue);
   return defaultValue;
}

那么，我们什么时候可以用orElse()? 当默认值是某个常量对象时，首选使用orElse。在上述所有情况下，我们都可以使用option . orelseget()(仅在Optional包含空值时执行)而不是option . orelse()。为什么? ?在orElse中，我们传递默认的结果值，但在orElseGet中，我们传递Supplier和Supplier的方法，只有当Optional中的值为空时才执行。

这里的关键要点是:

不要使用“可选”。orElse”，如果它包含任何日志语句。 不要使用“可选”。orElse”，如果它包含时间密集型逻辑。 不要使用“可选”。如果它正在改变某个对象状态，则使用orElse。 使用“可选的。orElse”如果我们必须返回一个常量，enum。 更喜欢“可选的。orElseGet”在1、2和3点提到的情况下。

我在第2点(“Optional.map/Optional。orElse " != " if/else ")我的媒体博客。作为程序员使用Java8，而不是作为编码器

以以下两种情况为例:

Optional<Foo> opt = ...
Foo x = opt.orElse( new Foo() );
Foo y = opt.orElseGet( Foo::new );

如果opt不包含值，则两者确实是等效的。但是如果opt包含一个值，将创建多少个Foo对象?

附注:当然，在这个例子中，差异可能无法测量，但如果您必须从远程web服务或数据库获取默认值，那么它就变得非常重要了。