Java 8 – How to Use Optional in Java

Introduction

Java 8 introduced the Optional class as a way to handle the absence of values in a more expressive and less error-prone way than using null. Optional is a container object that may or may not contain a non-null value. By using Optional, you can avoid common pitfalls associated with null, such as NullPointerException, and write more readable and maintainable code.

In this guide, we’ll explore how to use Optional in Java 8, covering the most common use cases and patterns.

Table of Contents

• Problem Statement
• Solution Steps
• Java Program
  • Example 1: Creating an Optional
  • Example 2: Checking if a Value is Present
  • Example 3: Providing a Default Value
  • Example 4: Throwing an Exception if Value is Absent
  • Example 5: Transforming Values with map()
  • Example 6: Chaining Operations with flatMap()
  • Example 7: Filtering Values in Optional
• Conclusion

Problem Statement

Handling null values in Java can be cumbersome and error-prone. The goal is to use Optional to handle values that might be absent in a more controlled, expressive, and safe manner.

Example:

• Problem: Using null directly can lead to NullPointerException and unclear code.
• Goal: Use Optional to handle potentially absent values in a clean and effective way.

Solution Steps

1. Create an Optional: Understand how to create Optional instances.
2. Check if a Value is Present: Learn how to check for the presence of a value in an Optional.
3. Provide a Default Value: Use methods to return a default value if the Optional is empty.
4. Throw an Exception if Absent: Handle cases where the absence of a value should trigger an exception.
5. Transform Values: Use map() and flatMap() to transform and chain operations on Optional values.
6. Filter Values: Apply conditions to the value inside an Optional and filter out unwanted results.

Java Program

Example 1: Creating an Optional

You can create an Optional in several ways, depending on whether you expect the value to be present or not.

import java.util.Optional;

/**
 * Java 8 - Creating an Optional
 * Author: https://www.rameshfadatare.com/
 */
public class OptionalExample1 {

    public static void main(String[] args) {
        // Creating an empty Optional
        Optional<String> emptyOptional = Optional.empty();

        // Creating an Optional with a non-null value
        Optional<String> nonEmptyOptional = Optional.of("Hello");

        // Creating an Optional that may contain a null value
        Optional<String> nullableOptional = Optional.ofNullable(null);

        System.out.println("Empty Optional: " + emptyOptional);
        System.out.println("Non-empty Optional: " + nonEmptyOptional);
        System.out.println("Nullable Optional: " + nullableOptional);
    }
}

Output

Empty Optional: Optional.empty
Non-empty Optional: Optional[Hello]
Nullable Optional: Optional.empty

Explanation

• Optional.empty(): Creates an empty Optional with no value.
• Optional.of(): Creates an Optional with a non-null value. Throws NullPointerException if the value is null.
• Optional.ofNullable(): Creates an Optional that can contain either a non-null value or null.

Example 2: Checking if a Value is Present

To check whether an Optional contains a value, use the isPresent() and ifPresent() methods.

import java.util.Optional;

/**
 * Java 8 - Checking if a Value is Present in Optional
 * Author: https://www.rameshfadatare.com/
 */
public class OptionalExample2 {

    public static void main(String[] args) {
        Optional<String> optional = Optional.of("Hello");

        // Checking if a value is present
        if (optional.isPresent()) {
            System.out.println("Value is present: " + optional.get());
        } else {
            System.out.println("Value is not present");
        }

        // Using ifPresent to perform an action if a value is present
        optional.ifPresent(value -> System.out.println("Value: " + value));
    }
}

Output

Value is present: Hello
Value: Hello

Explanation

• isPresent(): Returns true if the Optional contains a value, otherwise false.
• ifPresent(): Executes a block of code (typically a lambda expression) if the value is present.

Example 3: Providing a Default Value

You can provide a default value to be returned if the Optional is empty using orElse() and orElseGet().

import java.util.Optional;

/**
 * Java 8 - Providing a Default Value with Optional
 * Author: https://www.rameshfadatare.com/
 */
public class OptionalExample3 {

    public static void main(String[] args) {
        Optional<String> emptyOptional = Optional.empty();

        // Provide a default value if the Optional is empty
        String defaultValue = emptyOptional.orElse("Default Value");
        System.out.println("Value: " + defaultValue);

        // Provide a default value using a supplier
        String suppliedValue = emptyOptional.orElseGet(() -> "Supplied Value");
        System.out.println("Value: " + suppliedValue);
    }
}

Output

Value: Default Value
Value: Supplied Value

Explanation

• orElse(): Returns the value if present; otherwise, returns the provided default value.
• orElseGet(): Returns the value if present; otherwise, it invokes a Supplier to provide the default value.

Example 4: Throwing an Exception if Value is Absent

Sometimes, the absence of a value should result in an exception. You can use orElseThrow() for this purpose.

import java.util.Optional;

/**
 * Java 8 - Throwing an Exception with Optional
 * Author: https://www.rameshfadatare.com/
 */
public class OptionalExample4 {

    public static void main(String[] args) {
        Optional<String> emptyOptional = Optional.empty();

        // Throw an exception if the value is not present
        try {
            String value = emptyOptional.orElseThrow(() -> new IllegalArgumentException("Value not present"));
            System.out.println("Value: " + value);
        } catch (Exception e) {
            System.err.println(e.getMessage());
        }
    }
}

Output

Value not present

Explanation

• orElseThrow(): Throws the specified exception if the Optional is empty.

Example 5: Transforming Values with map()

The map() method allows you to transform the value inside an Optional if it is present.

import java.util.Optional;

/**
 * Java 8 - Transforming Values with Optional.map()
 * Author: https://www.rameshfadatare.com/
 */
public class OptionalExample5 {

    public static void main(String[] args) {
        Optional<String> optional = Optional.of("Hello");

        // Transform the value inside the Optional
        Optional<String> upperCaseValue = optional.map(String::toUpperCase);
        upperCaseValue.ifPresent(value -> System.out.println("Uppercase Value: " + value));
    }
}

Output

Uppercase Value: HELLO

Explanation

• map(): Applies the given function to the value if it is present and returns an Optional containing the result.

Example 6: Chaining Operations with flatMap()

Use flatMap() when the function you apply returns an Optional.

import java.util.Optional;

/**
 * Java 8 - Chaining Operations with Optional.flatMap()
 * Author: https://www.rameshfadatare.com/
 */
public class OptionalExample6 {

    public static void main(String[] args) {
        Optional<String> optional = Optional.of("Hello");

        // Chain operations with flatMap
        Optional<Integer> length = optional.flatMap(value -> Optional.of(value.length()));
        length.ifPresent(len -> System.out.println("Length: " + len));
    }
}

Output

Length: 5

Explanation

• flatMap(): Similar to map(), but the function applied returns an Optional, which is then flattened into a single Optional.

Example 7: Filtering Values in Optional

You can filter the value in an Optional based on a condition using the filter() method.

import java.util.Optional;

/**
 * Java 8 - Filtering Values in Optional
 * Author: https://www.rameshfadatare.com/
 */
public class OptionalExample7 {

    public static void main(String[] args) {
        Optional<String> optional = Optional.of("Hello");

        // Filter the value based on a condition
        Optional<String> filteredValue = optional.filter(value -> value.startsWith("H"));
        filteredValue.ifPresent(value -> System.out.println("Filtered Value: " + value));
    }
}

Output

Filtered Value: Hello

Explanation

• filter(): Applies a predicate to the value, returning the value if it matches the predicate or an empty Optional if it doesn’t.

Conclusion

The Optional class in Java 8 provides a powerful and flexible way to handle values that might be absent. By using Optional, you can avoid NullPointerException, write more expressive code, and make your intentions clear when dealing with null values. Whether you’re transforming values, providing defaults, or throwing exceptions, Optional offers a variety of methods to handle these scenarios cleanly and effectively.