> Java > Optional Class in Java

Optional Class in Java

Last Updated: 18 November, 2023

Optional is a public and final class in Java; it was introduced in the Java 8 version and is available in the java.util package.

Optional class is used to deal with NullPointerException in Java applications and helps in writing neat code without using too many null check conditions.

The Optional class provides various methods for checking whether a variable has a null value or not, and by doing this, we can avoid the NullPointerException at runtime.

Class declaration:

  public final class Optional<T> extends Object

Optional is a generic class that accept a type parameter T. In addition, it uses the final modifier, which prevents other classes from inheriting it.

Advantages of the Java Optional Class:

Null checks are not required in code.
There will be no more NullPointerException at runtime.
We can develop clean and neat Java applications and APIs.
No more boilerplate code

Optional class provides a type-level solution for representing optional values instead of null references.

Let's see an example below where we are not using the Optional class in the program, so during execution, the program terminates abnormally and throws a NullPointerException.

Example 1: Java Program without using Optionl class.

  
  import java.util.Optional;
  public class ProgramWithoutOptinal {
    public static void main(String[] args) {
      String[] str = new String[5];
      System.out.print(str[3].toUpperCase());
    }
  }

Output

Exception in thread "main" java.lang.NullPointerException at com.javabytechie.optional.ProgramWithoutOptinal.main(ProgramWithoutOptinal.java:7)

Optional class is used to prevent unexpected program termination. We'll use Optional in the following example.

Example 2: Java Program with using Optionl class.

  
  import java.util.Optional;
  public class ProgramWithOptinal {
    public static void main(String[] args) {
      String[] str = new String[5];
      Optional<String> checkNull = Optional.ofNullable(str[3]);
      if (checkNull.isPresent()) {
        String capsString = str[3].toUpperCase();
        System.out.print(capsString);
      } else
        System.out.println("string value is not present");
    }
  }

Output

string value is not present

The Optional class contains both static and instance methods. Static methods are called using the Option class name; to invoke an instance method, we need to create an instance of the Optinal class.

First, let's see all the static methods of the Optional class in the given table below.

Java Optional class static methods:

Methods	Descriptions
public static <T> Optional<T> empty()	This method will return an empty Optional instance.
public static <T> Optional<T> of(T value)	It returns an Optional with the specified present non-null value. Throws NullPointerException if the value is null.
public static <T> Optional<T> ofNullable(T value)	It returns an Optional describing the specified value if it is non-null; otherwise, it returns an empty Optional.

There are the following instance methods of the Optional class in Java.

Java Optional class instance methods:

Methods	Description
public T get()	If a value is present in this Optional, returns the value, otherwise throws NoSuchElementException.
public boolean isPresent()	It returns true if there is a value present, otherwise false.
public void ifPresent(Consumer<? super T> consumer)	If a value is present, invoke the specified consumer with the value, otherwise do nothing.
public Optional<T> filter(Predicate<? super T> predicate)	If a value is present, and the value matches the given predicate, return an Optional describing the value, otherwise return an empty Optional.
public <U> Optional<U> map(Function<? super T,? extends U> mapper)	If a value is present, apply the provided mapping function to it, and if the result is non-null, return an Optional describing the result. Otherwise return an empty Optional.
public <U> Optional<U> flatMap(Function<? super T,Optional<U> mapper)	If a value is present, apply the provided Optional-bearing mapping function to it, return that result, otherwise return an empty Optional.
public T orElse(T other)	It returns the value if present, otherwise returns other.
public T orElseGet(Supplier<? extends T> other)	It returns the value if present, otherwise invoke other and return the result of that invocation.
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X extends Throwable	It returns the contained value, if present, otherwise throw an exception to be created by the provided supplier.
public boolean equals(Object obj)	Indicates whether some other object is "equal to" this Optional or not.
public int hashCode()	It returns the hash code value of the present value, if any, or returns 0 (zero) if no value is present.
public String toString()	Returns a non-empty string representation of this Optional suitable for debugging.

There are some examples given; let's see and understand the uses of each method of the Optionl class in a Java program.

Example 1: empty() method

The empty() method is a static method; it returns an empty Optional instance.

  
  import java.util.Optional;
  public class OptionalExample1 {
    public static void main(String[] args) {
      // returns a empty Optional
      Optional<String> emptyOptional = Optional.empty();
      System.out.println(emptyOptional);
    }
  }

Output

Optional.empty

Example 2: of() method

The of() is a static method; it returns an Optional with the specified present non-null value. This method will throw a NullPointerException if the value is null.

  
  import java.util.Optional;
  public class OptionalExample2 {
    public static void main(String[] args) {
      // returns a non-empty Optional with value
      Optional<String> nonEmptyOptional = Optional.of("JavaByTechie");
      System.out.println(nonEmptyOptional); // Optional[JavaByTechie]
      System.out.println(Optional.of(null)); // throws NullPointerException
    }
  }

Output

Optional[JavaByTechie]
Exception in thread "main" java.lang.NullPointerException at java.util.Objects.requireNonNull(Objects.java:203) at java.util.Optional.<init>(Optional.java:96) at java.util.Optional.of(Optional.java:108) at com.javabytechie.optional.OptionalExample2.main(OptionalExample2.java:10)

Example 3: ofNullable() method

The ofNullable() is a static method; it returns an Optional describing the specified value, if non-null; otherwise, it returns an empty Optional.

  
  import java.util.Optional;
  public class OptionalExample3 {
    public static void main(String[] args) {
      Optional<String> nonEmptyOptional = Optional.ofNullable("JavaByTechie");
      Optional<String> emptyOptional = Optional.ofNullable(null);
      // Returns an Optional describing the specified value, if
      // non-null, otherwise returns an empty Optional.
      System.out.println(nonEmptyOptional);
      System.out.println(emptyOptional);
    }
  }

Output

Optional[JavaByTechie]
Optional.empty

Example 4: isPresent() method

The isPresent() method returns true if there is a value present; otherwise, it returns false.

    
    import java.util.Optional;
    public class OptionalExample4 {
        public static void main(String[] args) {
            Optional<String> nonEmptyOptional = Optional.of("JavaByTechie");
            Optional<String> emptyOptional = Optional.empty();
            // returns true if value Present otherwise false
            System.out.println("emptyOptional.isPresent(): " + emptyOptional.isPresent());
            System.out.println("nonEmptyOptional.isPresent(): " + nonEmptyOptional.isPresent());
        }
    }

Output

emptyOptional.isPresent(): false
nonEmptyOptional.isPresent(): true

Example 5: filter() method

If a value is present and the value matches the given predicate, return an Optional describing the value; otherwise, return an empty Optional. This method will throw a NullPointerException if the predicate is null.

    
    import java.util.Optional;
    import java.util.function.Predicate;
    public class OptionalExample5 {
        public static void main(String[] args) {
            Optional<String> nonEmptyOptional = Optional.of("JavaByTechie");
            Optional<String> emptyOptional = Optional.empty();
            
            /* filter() - If a value is present, and value matches the given predicate, 
             return an Optional otherwise return an empty Optional. */
            Predicate<String> predicate = s -> s.contains("Techie");
            System.out.println(nonEmptyOptional.filter(predicate));
            System.out.println(nonEmptyOptional.filter(s -> s.equals("Java")));
            System.out.println(emptyOptional.filter(predicate));
            System.out.println(nonEmptyOptional.filter(s -> s.startsWith("J")));
        }
    }

Output

Optional[JavaByTechie]
Optional.empty
Optional.empty
Optional[JavaByTechie]

Example 6: map() method

If a value is present, apply the provided mapping function to it, and if the result is non-null, return an Optional describing the result. Otherwise, return an empty Optional. This method will throw a NullPointerException if the mapping function is null.

    
    import java.util.Optional;
    import java.util.function.Function;
    public class OptionalExample6 {
        public static void main(String[] args) {
            Optional<String> nonEmptyOptional = Optional.of("JavaByTechie");
            Optional<String> emptyOptional = Optional.empty();
            /*
             * map() - If a value is present, apply the provided mapping function to
             * it, and if the result is non-null, return an Optional describing the
             * result. Otherwise return an empty Optional.
             */
            Function<String, String> function = s -> s.substring(0, 0).length() == 0 ? null : s;
            System.out.println(nonEmptyOptional.map(function));
            System.out.println(nonEmptyOptional.map(String::toLowerCase));
            System.out.println(emptyOptional.map(function));
        }
    }

Output

Optional.empty
Optional[javabytechie]
Optional.empty

Example 7: flatMap() method

If a value is present, apply the provided Optional-bearing mapping function to it, return that result, otherwise return an empty Optional. This method is similar to map(Function), but the provided mapper is one whose result is already an Optional, and if invoked, flatMap does not wrap it with an additional Optional. This method will throw NullPointerException if the mapping function is null or returns a null result.

    
    import java.util.Optional;
    import java.util.function.Function;
    public class OptionalExample7 {
        public static void main(String[] args) {
            /*
             * flatMap() - This method is similar to map(Function), but the provided
             * mapper is one whose result is already an Optional, and if invoked,
             * flatMap does not wrap it with an additional Optional.
             */
    
            Optional<Optional> optionalContainer = Optional.of(Optional.of("JavaByTechie"));
            Optional<Optional> emptyOptionalContainer = Optional.of(Optional.of("JavaByTechie"));
    
            Function<String, String> function = s -> s.substring(0, 0).length() == 0 ? null : s;
            Function<String, String> function2 = s -> s.substring(0, 5);
    
            System.out.println(optionalContainer.map(optional -> optional.map(function2)));
            System.out.println(optionalContainer.flatMap(optional -> optional.map(function2)));
            System.out.println(emptyOptionalContainer.flatMap(optional -> optional.map(function)));
        }
    }

Output

Optional[Optional[JavaB]]
Optional[JavaB]
Optional.empty

Example 8: orElse() method

    
    import java.util.Optional;
    public class OptionalExample8 {
        public static void main(String[] args) {
            Optional<String> nonEmptyOptional = Optional.of("JavaByTechie");
            Optional<String> emptyOptional = Optional.empty();
                
            // Return the value if present, otherwise return other.
            System.out.println(nonEmptyOptional.orElse("Core Java"));
            System.out.println(emptyOptional.orElse("Online Java Tutorial"));
        }
    }

Output

JavaByTechie
Online Java Tutorial

Example 9: orElseGet() method

    
    import java.util.Optional;
    import java.util.function.Supplier;
    public class OptionalExample9 {
        public static void main(String[] args) {
            Optional<String> nonEmptyOptional = Optional.of("Core Java Tutorial");
            Optional<String> emptyOptional = Optional.empty();
                
            /* orElseGet - Return the value if present, otherwise invoke other 
            and return the result of that invocation.*/
            Supplier<String> supplier = () -> "JavaByTechie";
            
            System.out.println(nonEmptyOptional.orElseGet(supplier));
            System.out.println(emptyOptional.orElseGet(supplier));
        }
    }

Output

Core Java Tutorial
JavaByTechie

Example 10: orElseThrow() method

    
    import java.util.Optional;
    public class OptionalExample10 {
        public static void main(String[] args) {
            Optional<String> nonEmptyOptional = Optional.of("JavaByTechie");
            Optional<String> emptyOptional = Optional.empty();
            
            // orElseThrow() - Return the contained value, if present, otherwise 
            //throw an exception to be created by the provided supplier.
            /*----------------------------------------------------------*/
            System.out.println(nonEmptyOptional.orElseThrow(NullPointerException::new)); 
            System.out.println(emptyOptional.orElseThrow(NullPointerException::new));
      }
    }

Output

JavaByTechie
Exception in thread "main" java.lang.NullPointerException at java.util.Optional.orElseThrow(Optional.java:290) at com.javabytechie.optional.OptionalExample10.main(OptionalExample10.java:13)

Note: Optional class is not meant to replace null checks or exceptions in all situations. It is especially helpful when a value might not be there, but that is an expected situation that needs to be dealt with. Optional can make code easier to read and more expressive by making it clearer when a value is not present and by letting functional actions be chained together.

Reference: https://docs.oracle.com/javase/8/docs/api/java/util/Optional

That's all guys, hope this Java article is helpful for you.

Happy Learning... 😀

Please share this article on social media to help others.

If you have any query or suggestion regarding this artical please share with us
feedback@javabytechie.com

Optional Class in Java

Advantages of the Java Optional Class:

Java Optional class static methods:

Java Optional class instance methods:

Example 1: empty() method

Example 2: of() method

Example 3: ofNullable() method

Example 4: isPresent() method

Example 5: filter() method

Example 6: map() method

Example 7: flatMap() method

Example 8: orElse() method

Example 9: orElseGet() method

Example 10: orElseThrow() method

Currently No Video available