Difference between Optional orElse and Optional orElseGet

Question

I am trying to understand the difference between the Optional lt T gt  orElse   and Optional lt T gt  orElseGet   methods    The description for the orElse   method is  Return the value if present  otherwise return other    While  the description for the orElseGet   method is  Return the value if present  otherwise invoke other and return the result of that invocation    The orElseGet   method takes a Supplier functional interface  which essentially does not take any parameters and returns T    In which situation would you need to use orElseGet    If you have a method T myDefault   why wouldn t you just do optional orElse myDefault    rather than optional orElseGet    - gt  myDefault       It does not seem that orElseGet   is postponing the execution of the lambda expression to some later time or something  so what s the point of it   I would have thought that it would be more useful if it returned a safer Optional lt T gt  whose get   never throws a NoSuchElementException and isPresent   always returns true    but evidently its not  it just returns T like orElse      Is there some other difference I am missing

User · Answer

The difference is pretty subtle and if you dont pay much attention then you will keep it using in a wrong way.

Best way to understand the difference between orElse() and orElseGet() is that orElse() will always be executed if the Optional<T> is null or not, But orElseGet() will only be executed when Optional<T> is null.

The dictionary meaning of orElse is :- execute the part when something is not present, but here it contradicts, see the below example:

    Optional<String> nonEmptyOptional = Optional.of("Vishwa Ratna");
    String value = nonEmptyOptional.orElse(iAmStillExecuted());

    public static String iAmStillExecuted(){
    System.out.println("nonEmptyOptional is not NULL,still I am being executed");
    return "I got executed";
    }

Output: nonEmptyOptional is not NULL,still I am being executed

    Optional<String> emptyOptional = Optional.ofNullable(null);
    String value = emptyOptional.orElse(iAmStillExecuted());
    public static String iAmStillExecuted(){
    System.out.println("emptyOptional is NULL, I am being executed, it is normal as 
    per dictionary");
    return "I got executed";
    }

Output: emptyOptional is NULL, I am being executed, it is normal as per dictionary

For orElseGet() , The method goes as per dictionary meaning, The orElseGet() part will be executed only when the Optional is null.

Benchmarks:

+--------------------+------+-----+------------+-------------+-------+
| Benchmark          | Mode | Cnt | Score      | Error       | Units |
+--------------------+------+-----+------------+-------------+-------+
| orElseBenchmark    | avgt | 20  | 60934.425  | ± 15115.599 | ns/op |
+--------------------+------+-----+------------+-------------+-------+
| orElseGetBenchmark | avgt | 20  | 3.798      | ± 0.030     | ns/op |
+--------------------+------+-----+------------+-------------+-------+

Remarks: orElseGet() has clearly outperformed orElse() for our particular example.

Hope it clears the doubts of people like me who wants the very basic ground example :)

User · Answer

The following example should demonstrate the difference  String destroyTheWorld          destroy the world logic   return  quot successfully destroyed the world quot      Optional lt String gt  opt   Optional of  quot Save the world quot        we re dead opt orElse destroyTheWorld         we re safe     opt orElseGet    - gt  destroyTheWorld      The answer appears in the docs as well  public T orElseGet Supplier lt   extends T gt  other    Return the value if present  otherwise invoke other and return the result of that invocation   The Supplier won t be invoked if the Optional presents  whereas  public T orElse T other    Return the value if present  otherwise return other   If other is a method that returns a string  it will be invoked  but it s value won t be returned in case the Optional exists

User · Answer

I reached here for the problem Kudo mentioned  I m sharing my experience for others  orElse  or orElseGet  that is the question  static String B         System out println  quot B      quot        return  quot B quot      public static void main final String    args        System out println Optional of  quot A quot   orElse B          System out println Optional of  quot A quot   orElseGet    - gt  B         prints B      A A  orElse evaluates the value of B   interdependently of the value of the optional  Thus  orElseGet is lazy

User · Answer

Take these two scenarios   Optional lt Foo gt  opt       Foo x   opt orElse  new Foo      Foo y   opt orElseGet  Foo  new      If opt doesn t contain a value  the two are indeed equivalent  But if opt does contain a value  how many Foo objects will be created   P s   of course in this example the difference probably wouldn t be measurable  but if you have to obtain your default value from a remote web service for example  or from a database  it suddenly becomes very important

User · Answer

Short Answer   orElse   will always call the given function whether you want it or not  regardless of Optional isPresent   value orElseGet   will only call the given function when the Optional isPresent      false  In real code  you might want to consider the second approach when the required resource is expensive to get     Always get heavy resource getResource resourceId  orElse getHeavyResource          Get heavy resource when required  getResource resourceId  orElseGet    - gt  getHeavyResource      For more details  consider the following example with this function  public Optional lt String gt  findMyPhone int phoneId   The difference is as below                             X   buyNewExpensivePhone   called                                                                                                                                                                                                                                                                  Optional isPresent                                       true   false                                                                                                                                                                                                                                                         findMyPhone int phoneId  orElse buyNewExpensivePhone                 X      X                                                                                                                                                                                                                                                           findMyPhone int phoneId  orElseGet    - gt  buyNewExpensivePhone               X                                                                                                                                                                                                                                                          When optional isPresent      false  there is no difference between two ways  However  when optional isPresent      true  orElse   always calls the subsequent function whether you want it or not  Finally  the test case used is as below  Result  ------------- 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  Code  public class TestOptional       public Optional lt String gt  findMyPhone int phoneId            return phoneId    10                   Optional of  quot MyCheapPhone quot                     Optional empty               public String buyNewExpensivePhone             System out println  quot  tGoing to a very far store to buy a new expensive phone quot            return  quot NewExpensivePhone quot               public static void main String   args            TestOptional test   new TestOptional            String phone          System out println  quot ------------- Scenario 1 - orElse   -------------------- quot            System out println  quot   1 1  Optional isPresent      true  Redundant call  quot            phone   test findMyPhone 10  orElse test buyNewExpensivePhone             System out println  quot  tUsed phone   quot    phone    quot  n quot             System out println  quot   1 2  Optional isPresent      false quot            phone   test findMyPhone -1  orElse test buyNewExpensivePhone             System out println  quot  tUsed phone   quot    phone    quot  n quot             System out println  quot ------------- Scenario 2 - orElseGet   -------------------- quot            System out println  quot   2 1  Optional isPresent      true quot               Can be written as test  buyNewExpensivePhone         phone   test findMyPhone 10  orElseGet    - gt  test buyNewExpensivePhone             System out println  quot  tUsed phone   quot    phone    quot  n quot             System out println  quot   2 2  Optional isPresent      false quot            phone   test findMyPhone -1  orElseGet    - gt  test buyNewExpensivePhone             System out println  quot  tUsed phone   quot    phone    quot  n quot

User · Answer

First of all check the declaration of both the methods   1  OrElse  Execute logic and pass result as argument   public T orElse T other         return value    null   value   other      2  OrElseGet  Execute logic if value inside the optional is null  public T orElseGet Supplier lt   extends T gt  other      return value    null   value   other get         Some explanation on above declaration  The argument of    Optional orElse    always gets executed irrespective of the value of the object in optional  null  empty or with value   Always consider the above-mentioned point in mind while using    Optional orElse     otherwise use of    Optional orElse    can be very risky in the following situation   Risk-1  Logging Issue  If content inside orElse contains any log statement  In this case  you will end up logging it every time   Optional of getModel        map x - gt            some logic          orElse getDefaultAndLogError      getDefaultAndLogError       log error  No Data found  Returning default      return defaultValue      Risk-2  Performance Issue  If content inside orElse is time-intensive  Time intensive content can be any i o operations DB call  API call  file reading  If we put such content in orElse    the system will end up executing a code of no use   Optional of getModel        map x - gt    some logic      orElse getDefaultFromDb      getDefaultFromDb        return dataBaseServe getDefaultValue      api call  db call      Risk-3  Illegal State or Bug Issue  If content inside orElse is mutating some object state  We might be using the same object at another place let say inside Optional map function and it can put us in a critical bug   List lt Model gt  list   new ArrayList lt  gt     Optional of getModel       map x - gt            orElse get list     get List  lt  String  gt  list       log error  No Data found  Returning default       list add defaultValue      return defaultValue      Then  When can we go with orElse    Prefer using orElse when the default value is some constant object  enum  In all above cases we can go with Optional orElseGet    which only executes when Optional contains non empty value instead of Optional orElse    Why   In orElse  we pass default result value  but in orElseGet we pass Supplier and method of Supplier only executes if the value in Optional is null   Key takeaways from this    Do not use    Optional orElse    if it contains any log statement  Do not use    Optional orElse    if it contains time-intensive logic  Do not use    Optional orElse    if it is mutating some object state  Use    Optional orElse    if we have to return a constant  enum  Prefer    Optional orElseGet    in the situations mentioned in 1 2 and 3rd points    I have explained this in point-2     Optional map Optional orElse          if else     my medium blog  Use Java8 as a programmer not as a coder

User · Answer

I would say the biggest difference between orElse and orElseGet comes when we want to evaluate something to get the new value in the else condition   Consider this simple example -     oldValue is String type field that can be NULL String value  if  oldValue    null        value   oldValue    else       value   apicall   value      Now let s transform the above example to using Optional along with orElse      oldValue is Optional type field String value   oldValue orElse apicall   value     Now let s transform the above example to using Optional along with orElseGet      oldValue is Optional type field String value   oldValue orElseGet    - gt  apicall   value     When orElse is invoked  the apicall   value is evaluated and passed to the method  Whereas  in the case of orElseGet the evaluation only happens if the oldValue is empty  orElseGet allows lazy evaluation

User · Answer

Considering the following code   import java util Optional      one class needs to have a main   method public class Test     public String orelesMethod         System out println  in the Method        return  hello          public void test         String value      value   Optional  lt String gt ofNullable  test   orElseGet this  orelesMethod       System out println value         value   Optional  lt String gt ofNullable  test   orElse orelesMethod         System out println value              arguments are passed using the text field below this editor   public static void main String   args          Test test   new Test         test test            if we get value in this way  Optional  lt String gt ofNullable null   there is no difference between orElseGet   and orElse    but if we get value in this way  Optional  lt String gt ofNullable  test    orelesMethod   in orElseGet   will not be called but in orElse   it will be called

[java] Difference between `Optional.orElse()` and `Optional.orElseGet()`

Examples related to java

Examples related to java-8

Examples related to optional