The Optional class was introduced in Java 8 to handle null values more elegantly. It is a container object which may or may not contain a non-null value. It provides a way to represent null values and also method to handle null values without throwing a NullPointerException.
In this post, we will explore some common use cases of the Optional class.
Avoiding NullPointerExceptions
Before Optional, we had to do null checks like this:
String name = getName();if (name != null) {int length = name.length();// use length}
With Optional, we can rewrite this as:
Optional<String> name = Optional.ofNullable(getName());if (name.isPresent()) {int length = name.get().length();// use length}
This avoids the NullPointerException if getName() returns null.
Default Values
We can provide a default value if the Optional is empty using orElse():
Optional<String> name = Optional.ofNullable(getName());String defaultName = "Default Name";String result = name.orElse(defaultName);
result will be "Default Name" if name is empty.
Conditional Processing
We can use ifPresent() to execute a block of code if the Optional has a value:
Optional<String> name = Optional.ofNullable(getName());name.ifPresent(n -> System.out.println(n.length()));
This will print the length of the name if it has a value, and do nothing if empty.
Mapping Values
We can use map() to apply a function to the value inside an Optional and return an Optional with the result. For example:
Optional<String> name = Optional.of("John");Optional<Integer> length = name.map(String::length);// length is Optional[4]
If the Optional is empty, the mapping function is not called and an empty Optional is returned.
Chaining Optionals
We can chain multiple Optionals using flatMap():
Optional<String> name = Optional.of("John");Optional<String> upperName = name.map(String::toUpperCase);// upperName is Optional["JOHN"]Optional<String> firstName = Optional.of("John");Optional<String> lastName = Optional.of("Doe");Optional<String> fullName = firstName.flatMap(f -> lastName.map(l -> f + " " + l));// fullName is Optional["John Doe"]
If any Optional in the chain is empty, the final result will be an empty Optional.
Filtering Values
We can use filter() to filter out values that don't match a predicate. For example:
Optional<String> name = Optional.of("John");Optional<String> longName = name.filter(n -> n.length() > 4);// longName is Optional["John"]Optional<String> name = Optional.of("Jo");Optional<String> longName = name.filter(n -> n.length() > 4);// longName is empty
If the value does not match the predicate, an empty Optional is returned.
Here are a few more examples of Optional usages:
Finding First Present Value
We can use orElseGet() to provide a Supplier that will be called if the Optional is empty:
Optional<String> name = Optional.empty();String result = name.orElseGet(() -> "Default Name");// result is "Default Name"
This is useful when the default value is expensive to calculate.
Throwing an Exception
We can use orElseThrow() to throw an exception if the Optional is empty:
Optional<String> name = Optional.empty();String result = name.orElseThrow(IllegalArgumentException::new);// Throws IllegalArgumentException
Composing Multiple Optionals
We can use andThen() to compose two Optionals together, where the second Optional is applied to the value of the first:
Optional<String> name = Optional.of("John");Optional<String> upperName = name.andThen(Optional::of).map(String::toUpperCase);// upperName is Optional["JOHN"]
If either Optional is empty, the composed result will be empty.
Comparing Optionals
Two Optionals can be compared with equals() and hashCode():
Optional<String> a = Optional.of("a");Optional<String> b = Optional.of("b");Optional<String> c = Optional.empty();System.out.println(a.equals(b)); // falseSystem.out.println(a.equals(Optional.of("a"))); // trueSystem.out.println(a.equals(c)); // falseSystem.out.println(c.equals(Optional.empty())); // true
In addition, it's worth noting that Optional is not a silver bullet for all null-related problems. It's important to use it judiciously and not overuse it, as it can also make our code more complex and harder to read.
Here are some best practices to keep in mind when using Optional:
1. Use Optional to represent optional values, not absent values. If a value is required, don't use Optional to represent it.
2. Don't use Optional as a parameter or return type in public APIs. Optional is an implementation detail and should not be exposed in public APIs.
3. Don't use Optional to replace null checks everywhere. Use it only where it makes sense and improves the readability and robustness of the code.
4. Be aware of the performance implications of using Optional, especially in performance-critical code. Optional can have a small performance overhead compared to null checks.
5. Use Optional in combination with other Java features such as lambdas, streams, and functional interfaces to write more expressive and concise code.
6. Use orElse() for default values that are cheap to compute, and orElseGet() for default values that are expensive to compute.
7. Use filter() to filter out values that don't match a predicate, and use map() to transform values.
8. Use flatMap() to chain Optionals together, and use ifPresent() to conditionally execute code.
9. Use orElseThrow() to throw an exception if the Optional is empty.
10. Use equals() and hashCode() to compare Optionals.
By following these best practices, we can use Optional effectively and write more robust and expressive code.
In conclusion, Optional is a powerful feature in Java that can help us write more robust and expressive code. It provides a way to handle null values without throwing NullPointerExceptions and allows us to write more concise and readable code.
By using Optional effectively and following best practices, we can make our code more readable, maintainable, and performant. If you have any questions or feedback, please leave a comment below.