我试图理解Optional<T>. orelse()和Optional<T>. orelseget()方法之间的区别。

orElse()方法的描述是“如果存在则返回值,否则返回other”。

而orElseGet()方法的描述是“如果存在则返回值,否则调用other并返回该调用的结果。”

orElseGet()方法接受一个Supplier函数接口,该接口本质上不接受任何参数并返回T。

在哪种情况下需要使用orElseGet()?如果你有一个方法T myDefault()你为什么不只是做option . orelse (myDefault())而不是option . orelseget (() -> myDefault()) ?

似乎orElseGet()并没有将lambda表达式的执行推迟到以后的某个时间或其他时间,那么它的意义是什么呢?(我认为它会更有用,如果它返回一个更安全的Optional<T>,其get()从不抛出NoSuchElementException, isPresent()总是返回true…但显然不是,它只是像orElse()一样返回T。

还有其他的不同吗?


当前回答

我想说,orElse和orElseGet之间最大的区别是当我们想要在else条件下求值以获得新值时。

考虑这个简单的例子-

// oldValue is String type field that can be NULL
String value;
if (oldValue != null) {
    value = oldValue;
} else {
    value = apicall().value;
}

现在让我们将上面的例子转换为使用Optional和orElse,

// oldValue is Optional type field
String value = oldValue.orElse(apicall().value);

现在让我们将上面的例子转换为使用Optional和orElseGet,

// oldValue is Optional type field
String value = oldValue.orElseGet(() -> apicall().value);

当orElse被调用时,apicall()。值被计算并传递给方法。然而,在orElseGet的情况下,只有当oldValue为空时才会计算。orElseGet允许惰性求值。

其他回答

我想说,orElse和orElseGet之间最大的区别是当我们想要在else条件下求值以获得新值时。

考虑这个简单的例子-

// oldValue is String type field that can be NULL
String value;
if (oldValue != null) {
    value = oldValue;
} else {
    value = apicall().value;
}

现在让我们将上面的例子转换为使用Optional和orElse,

// oldValue is Optional type field
String value = oldValue.orElse(apicall().value);

现在让我们将上面的例子转换为使用Optional和orElseGet,

// oldValue is Optional type field
String value = oldValue.orElseGet(() -> apicall().value);

当orElse被调用时,apicall()。值被计算并传递给方法。然而,在orElseGet的情况下,只有当oldValue为空时才会计算。orElseGet允许惰性求值。

简短的回答:

不管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");
    }
}

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

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存在,它的值将不会返回。

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

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

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是懒惰的。

以以下两种情况为例:

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

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

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