Java Optional Class orElseThrow() Method

The Optional class from Java is an explicit container object that holds an object of the non-null value which may or may not exist. It was first used in Java 8 to provide a more capable, costly, and more safe approach for handling values that may be null.

Among all the methods of the Optional class, one can highlight orElseThrow(). This method either gives back the value contained in the Optional or throws an exception if the value is missing.

It gives a straight path to manage the condition in which we may want to have some value, but it might be absent; at the same time, it will not let us have a null pointer exception.

Purpose and Usage

The Optional class and it orElseThrow() method have two primary uses to offer a more functional approach to managing optional values. Optional outperforms the common practice of providing a null check before using an object in that the former is based on a more declarative approach in terms of resource usage.

When the problem is solved with nothingness, many faults associated with a null reference are eradicated since the absence of a value is handled overtly.

File Name: OptionalOrelsethrow.java

 
import java.util.Optional;
public class OptionalOrelsethrow{
    public static void main(String[] args) {
        Optional<String> optionalvalue = Optional.ofNullable(getValue());
        // Using orElseThrow to handle the absence of a value
        String value = optionalvalue.orElseThrow(() -> new IllegalArgumentException("Value is absent"));
        System.out.println("Value is: " + value);
    }
    // Example method that may return null
    private static String getValue() {
        return null; // Change this to a non-null value to avoid exception
    }
}   

Output:

 
ERROR!
Exception in thread "main" java.lang.IllegalArgumentException: Value is absent
	at Main.lambda$main$0(Main.java:8)
	at java.base/java.util.Optional.orElseThrow(Optional.java:408)
	at Main.main(Main.java:8)

Explanation

In this example, the getValue() method has been meant to demonstrate a situation in which one of the returned values could be null. It could depict a scenario such as a source of data being a database or other online application where the outcome of the function is not predetermined.

Creating an Optional: Optional.ofNullable(getValue()) returns Optional of type java. util that contains the result of the getValue() method. If the result is, therefore, null, the Optional will be empty.

Handling Absence with orElseThrow(): The orElseThrow() method is utilized to either pull out the value from the Optional or to get a thrown exception in case of the value does not exist.

The method gets a Supplier's functional interface that contains the exception to be thrown. Here, if Optional is empty, an exception of type java.util.InvalidException is created with the message "Value is absent".

Output: If getValue() is not equal to null, then that value is printed. If getValue() returns null, an IllegalArgumentException is thrown to signal a missing required value.

Explicit Null Handling: This makes the code much more overt and easy to read than when Optional and orElseThrow() are used. It makes sure that a method can produce an absent form and ensures that such a case has to be managed.

Reduced Risk of NullPointerException: In Optional, the JVM assures the developers that a particular value may not be available, hence minimizing the number of NullPointerExceptions.

Cleaner Code: It is an advantage in the sense that Optional can make code slightly cleaner by removing the need for multiple null checks.

Functional Style: Optional uses many of the functions like map(), flatMap(), filter(), and others for initializing and heading functional programming if the contained value exists.

Considerations

While Optional provides many benefits, it is not without its considerations: While Optional offers many benefits, it is not without its considerations:

Performance: Extensive use of Optional can result in the creation of objects that may not be used and, hence, an increase in the amount of overhead used. It is often advised when the return type rather than the field or method parameter is being declared.

Exception Handling: When using the orElseThrow() placeholder, the developers should choose proper exceptions and informative error messages.

Not a Replacement for Null: Optional is not to take over the use of null for all cases. It is a utility for those cases only where the value can be missing, and checks for nulls would have to be run often.

Conclusion

Optional orElseThrow() is also another Java-based method that tends to cater for possible absent values in Java. Because it aids in writing more reliable well-documented and extensible code by signifying of supposed to be a presence of a value. But in absence and by providing a technique to handle such a scenario efficiently. On the other hand, it is indispensable to use it appropriately, as with any tool, in order not to turn the abstractness of the code into a formalism trophy.

Next TopicJava-precondition

← prev next →