Developer.com content and product recommendations are editorially independent. We may earn money when you click on links to our partners. Find out more.
An Optional object in Java is a container object that can contain both empty and non-null values. If the Optional object contains a value, we say it is present; if it does not contain a value, we say it does empty. Here we will look at the optional class in Java and how it can be used to improve your code. We will also consider some of the disadvantages of using it Optional keyword in Java and some best practices.
Jump to:
What is Optional Type in Java?
Optional is a new type introduced in Java 8. It is used to represent a value that may or may not be present. In other words, an optional object can contain a non-null value (in which case it is considered present) or cannot contain any value (in which case it is considered empty).
An optional object can have one of the following possible states:
- Present: Optional object does not represent absence. The value is in the Optional object and can be accessed by calling it get() method.
- Absent: An optional object represents the absence of a value; you cannot access its content with get() method.
Why do developers need options in Java?
Optional is generally used as a return type for methods that may not always have a result to return. For example, a method that searches for a user by identity card may not find a match, in which case it will return an empty optional object.
Optionals can also help reduce the number of null pointer exceptions in your code. It is not intended as a replacement for existing reference types, such as Series or A listbut, rather, as an addition to a Java-type system.
How to create an optional object in Java
There are several ways to create an Optional object in Java, including static factory methods empty() and from(), which refer to the optional class. You can create an optional object using from() method, which will return an Optional object containing the given value if the value is not null, or an empty Optional object if the value is null.
Developers can also use ofNullable() method, which will return an empty Optional object if the value is null, or an Optional object containing the given value if it is not null. Finally, you can create an empty Optional object using empty() method.
After you have created an Optional object, you can use is present() method to check if it contains a non-zero value. If it exists, you can use it get() method to retrieve the value. Developers can also use getOrElse() method, which will return a value if present or a default value if not.
Read: An introduction to inner classes in Java
The Java isPresent and ifPresent methods
Developers can take advantage is present method to check if the Optional object is empty or not. The ifPresent method, meanwhile, can check whether a particular Optional object is non-empty. The following code example illustrates how you can work with ifPresent and is present methods in Java:
import java.util.Optional;
public class OptionalDemo
public static void main(String[] args)
Optional obj1 = Optional.of
("This is a sample text");
Optional obj2 = Optional.empty();
if (obj1.isPresent())
System.out.println
("isPresent method called on obj1 returned true");
obj1.ifPresent(s -> System.out.println
("ifPresent method called on obj1"));
obj2.ifPresent(s -> System.out.println
("ifPresent method called on obj2 "));
In the code example above, we first check for the existence of two Optional objects, using is present() method. We have assigned a value obj1so it will print the string “This is sample text”. obj2, however, is assigned an empty value, so it will print nothing. Then we print some more text to warn us ifPresent was invited to both of our Election facilities.
How to use Optional Objects in Java
There are several ways to create Optional objects. The most common way is to use the static factory method Optional.from(T)which creates an optional object that is present and contains the given non-null value, as shown in the code snippet below:
Optional optional = Optional.of("value");
Additionally, we can create an empty Optional object using a static factory method Optional. emptyas shown in the code example below:
Optional optional = Optional.empty();
If we have a value that might be null, we can use a static factory method Optional.ofNullable(T) to create an optional object that may or may not be present:
Optional optional = Optional.ofNullable(null);
Developers can also use methods like ifPresent() and or another() if you need to perform an action depending on whether the option is set (if it contains a certain value) or if it is not, that is:
Optional optionalString = Optional.of("value");
optionalString.ifPresent(s -> System.out.println(s));
Pros and cons of using optional objects in Java
There are several key benefits of using Optionals that Java developers should be aware of, including:
- Optionally, it can help in prevention NullPointerException errors by making it explicit when a variable may or may not contain a value. This can lead to cleaner and more readable code.
- Optional provides several methods that can be used to safely work with data that may or may not be present.
- Optional can be used as a regular class, meaning there is no need for special syntax to call methods or access fields.
Despite these advantages, there are several potential disadvantages of using the Optional option:
- Optional can add significant overhead to code runtime, because an Optional wrapper must be created and checked every time the variable is accessed.
- Some developers find Optional confusing and difficult to work with, which can lead to more errors instead of fewer, and as a result more development time and effort than usual.
Read: The best project management tools for developers
Alternatives to using optional objects in Java
There are several alternatives to using Optional, such as using zero check operator (?.)using an if-else statement, or by means of a triple operator.
The null check operator can be used to check whether a value is null before it is accessed. This can be done using ?. operator in front of the variable name. For example, the following Java code will check whether a variable abc is null before access:
if (abc != null) //Write your code here
If the variable abc not null, code within if the statement will be executed. The if-else statement in the above code checks if the value is null before accessing it.
Best practices for using options
Below are some best practices to consider when using the Optional option in your Java code:
- Use Optional to reduce the number of null pointer exceptions and account for times when returned values are empty or missing.
- Do not use Optional as a stop-gap for every type of null pointer. Coders must still consider constructor methods and parameters that can also contain null values.
- Consider the context of your Optional objects; absent Optional values can mean different things, such as a specific value not found or no value found. Consider these options.
- Use Optional as the return type, then retrieve its value if it’s present, or provide a different outcome if it’s not.
- Do not use the Optional a parameter for methods or constructors. Using it in such a way results in messy, hard-to-read and hard-to-maintain code.
Final thoughts on using optional objects in Java
Optional is a new feature in Java 8 that provides a way to handle null values in a more elegant way. The java.util.Optional class was introduced in Java 8 as a way to solve the common problem of null pointer exceptions. By using Optional developers can avoid NullPointerExceptions and write cleaner code.
Want to learn more about objects and classes in Java? We recommend that you read our guide What is an abstract class in Java as a next step.