How do I throw exceptions if Optional is empty using orElseThrow?

By Wayan in Util Package 0 Comment

In Java, you can throw exceptions when an Optional is empty using the orElseThrow method. This method accepts a Supplier that provides the exception to be thrown if the Optional is empty.

Here’s the syntax and an example:

package org.kodejava.util;

import java.util.Optional;

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

      // Throws an exception if Optional is empty
      String value = optionalValue.orElseThrow(() -> new IllegalArgumentException("Value is not present"));

      System.out.println(value);
   }
}

Explanation:

  1. orElseThrow():
    • This method is used to retrieve the value from an Optional.
    • If the Optional is empty (Optional.empty()), it throws the exception provided by the Supplier.
  2. Key Points:
    • orElseThrow takes a lambda expression or method reference as its argument. This lambda (or Supplier) returns the exception to be thrown.
    • Example of a custom exception:
    Optional<String> optionalValue = Optional.empty();

String value = optionalValue.orElseThrow(() -> new MyCustomException("Custom message"));
  3. Method Reference Example:
    If the exception has a default constructor, you can use a method reference:

    Optional<String> optionalValue = Optional.empty();

String value = optionalValue.orElseThrow(MyCustomException::new);
  4. When Optional is not empty:
    If the Optional contains a value (i.e., Optional.of("value")), the value is retrieved instead of throwing an exception.

    Optional<String> optionalValue = Optional.of("Hello");

String value = optionalValue.orElseThrow(() -> new IllegalArgumentException("Value is not present"));

System.out.println(value); // Prints "Hello"

Custom Exception Example:

If you want to define your own custom exception:

class MyCustomException extends RuntimeException {
    public MyCustomException(String message) {
        super(message);
    }
}

And use it with orElseThrow:

Optional<String> optionalValue = Optional.empty();

String value = optionalValue.orElseThrow(() -> new MyCustomException("Custom exception message"));

Using orElseThrow is a clean and concise way to handle empty Optional values by throwing appropriate exceptions.

How do I unwrap a value from an Optional safely?

By Wayan in Util Package 0 Comment

Unwrapping a value from an Optional in Java safely is a common concern. Java’s Optional is designed to handle null values more gracefully by avoiding NullPointerException. Below are some best practices to unwrap and access the value of an Optional safely:

1. Using Optional.ifPresent (Best for side effects)

If you don’t need to handle the value but perform an action when the value is present:

optional.ifPresent(value -> {
    // Process the value
    System.out.println("Value: " + value);
});

This is a safe way, as it checks if the value is present and only performs the action if it exists.

2. Using Optional.orElse (Provide a Default Value)

You can provide a default value in case the Optional is empty:

String result = optional.orElse("Default Value");
System.out.println(result);

Here, if optional has a value, it’ll return it; otherwise, it returns "Default Value".

3. Using Optional.orElseGet (Lazy Default Value)

If generating the default value is costly, use orElseGet, which accepts a supplier:

String result = optional.orElseGet(() -> "Generated Default");
System.out.println(result);

This is more efficient since the default value is only generated when the Optional is empty.

4. Using Optional.orElseThrow (Throw Exception If Empty)

If the absence of a value is considered an exception case, throw an exception:

String result = optional.orElseThrow(() -> new IllegalArgumentException("Value must be present"));
System.out.println(result);

Throwing an exception explicitly ensures you’re aware of the consequences.

5. Using optional.isPresent() and optional.get() (Not Preferred)

While you can directly check for the presence of a value and use get(), it is not recommended because it leads to unsafe usage:

if (optional.isPresent()) {
    String value = optional.get();
    System.out.println(value);
}

Using get() is less idiomatic and increases the potential for unsafe code.

6. Using Optional.map() (Transform if Present)

If you want to transform the contained value, use map() to perform the transformation safely:

optional.map(String::toUpperCase).ifPresent(System.out::println);

This method ensures that map() works only if the value is present.

Summary: Best Practices

  1. Use ifPresent if you have side effects (e.g., logging or processing).
  2. Use orElse or orElseGet when you need a default value.
  3. Use orElseThrow to throw exceptions for missing values.
  4. Avoid direct use of get().

The goal of Optional is to encourage safe handling of nullable values in a functional style without resorting to frequently problematic null checks.

How do I provide a default value using Optional?

By Wayan in Util Package 0 Comment

In Java, the Optional class provides a way to handle possible null values in a more functional style. If you’re using an Optional and want to provide a default value, you can do so using the orElse() or orElseGet() methods. Here’s an explanation and code examples for both:

1. Using Optional.orElse()

The orElse() method provides a default value that will be returned if the Optional is empty.

Example:

package org.kodejava.util;

import java.util.Optional;

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

        // If optional is empty, "Default Value" will be returned
        String result = optionalValue.orElse("Default Value");

        System.out.println(result); // Output: Default Value
    }
}

Here:

  • If the optionalValue is empty, the provided "Default Value" will be returned.
  • If it contains a value, that value will be used instead.

2. Using Optional.orElseGet()

The orElseGet() method works like orElse(), but it accepts a Supplier functional interface. This is useful if the default value requires some computation.

Example:

package org.kodejava.util;

import java.util.Optional;

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

        // Use a Supplier for the default value
        String result = optionalValue.orElseGet(() -> "Computed Default Value");

        System.out.println(result); // Output: Computed Default Value
    }
}

Here:

  • The orElseGet() method evaluates the lambda expression (or Supplier) only if the Optional is empty, making it more efficient if computation of the default value is expensive.

3. Key Differences:

  • orElse(): The default value is always evaluated, even if the Optional contains a value.
  • orElseGet(): The default value is lazily evaluated (only computed if needed, i.e., when the Optional is empty).

Example to Show the Difference:

package org.kodejava.util;

import java.util.Optional;

public class DefaultExample2 {
    public static void main(String[] args) {
        Optional<String> optionalValue = Optional.of("Present");

        // orElse: Supplier function is evaluated regardless of whether the Optional is empty or not
        String result1 = optionalValue.orElse(getDefaultValue());
        System.out.println(result1); // Output: Present (but still calls getDefaultValue())

        // orElseGet: Supplier function is only evaluated if Optional is empty
        String result2 = optionalValue.orElseGet(() -> getDefaultValue());
        System.out.println(result2); // Output: Present (doesn't call getDefaultValue())
    }

    public static String getDefaultValue() {
        System.out.println("Computing default value...");
        return "Default Value";
    }
}

4. Using Optional.orElseThrow()

An alternative is to throw an exception if the Optional is empty instead of providing a default value.

Example:

package org.kodejava.util;

import java.util.Optional;

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

        String result = optionalValue.orElseThrow(() -> new IllegalStateException("Value is missing"));

        // Will throw the exception: IllegalStateException: Value is missing
        System.out.println(result);
    }
}

Summary:

  • Use orElse() when you want to provide a default value directly.
  • Use orElseGet() when the default value requires expensive computation and should be lazily evaluated.
  • Use orElseThrow() if you want to throw an exception when the Optional is empty.