Java8 -Optional.orElseGet with Supplier defined inside () vs in method call - java-8

Question

As per the documentation the difference between
orElse and orElseGet is in the fact that in the case of orElseGet(x) the x part
is called incase Optional.isPresent is false
But in below program in case the supplier x is a another method call in orElseGet(x)
the x part is called even if Optional.isPresent is true similiar to the behavior of
orElse(). Why is the behavior of orElseGet() in this scenario same as orElse()?
import java.util.Optional;
import java.util.function.Supplier;
public class TestOrElseGet {
public static void main(String[] args) {
checkOrElseGet();
}
private static void checkOrElseGet() {
System.out.println("------Start Optional.orElseGet-------");
String first= getFirst();
// else part is not initialized
// else doesn't get initialized if its inside OrElseGet()
String myOptional = Optional.of(first).orElseGet(() -> {
System.out.println("OrElseGet - Create & Return Second");
return "Second";
});
System.out.println(
"Result of OrElseGet " + myOptional);
// if supplier is a method then its gets called
myOptional = Optional.of(getThird()).orElseGet(getNumberFromSupplier());
System.out.println(" Result of OrElseGet is "
+ myOptional);
Optional<String> empty = Optional.empty();
// OrElseGet - else is initialized as optional was empty
myOptional = empty.orElseGet(() -> {
System.out.println("OrElseGet - Create & Return Fourth");
return "Four" ;
});
System.out.println("Result of OrElseGEt is " + myOptional);
System.out.println("----------Completed-----------");
}
private static Supplier<String> getNumberFromSupplier() {
System.out.println("Inside Supplier call..");
return ()->{
return "Supplying TEN";
};
}
private static String getThird() {
System.out.println("Inside Third");
return "Third";
}
private static String getFirst() {
System.out.println("Inside GetFirst");
return "First";
}
}

Answer 1

The contract of orElseGet(Supplier) says the →Supplier← will only be invoked if the value is not present. More specifically, it's the Supplier#get() method that's lazily invoked (on the Supplier instance passed to orElseGet).
And your code shows that. However, this bit:
private static Supplier<String> getNumberFromSupplier() {
System.out.println("Inside Supplier call..");
return ()->{
return "Supplying TEN";
};
}
Indicates a misunderstanding. Your println log says "Inside Supplier call...", but at that point you are not inside the supplier. The Supplier is the lambda expression and is returned from the method. That said, you're correct that the getNumberFromSupplier method is invoked eagerly, but that's because its return value is passed as an argument to the orElseGet call. Even for orElseGet(() -> ... ) the Supplier is created eagerly for the same reason.
If you had the following:
private static Supplier<String> getNumberFromSupplier() {
// Remember, the lambda is the implementation of Supplier#get()
return () -> {
System.out.println("Inside Supplier call...");
return "Supplying TEN";
};
}
Then you'd see the Supplier is lazily invoked. Notice the new location for the println call. Additionally, the method would be better named getNumberSupplier as that's a more apt description of what the method actually does.