How do I combine multiple Optionals in functional-style code?

By I Wayan Saryada in Util Package 0 Comment

Combining multiple Optional objects in Java in a functional style is a common need, especially when working with potentially nullable values without resorting to null checks. Here are examples of some approaches you can use based on the scenario:

1. Combining If All Optionals Are Present

If you want to combine values only when all Optionals are non-empty, you can use flatMap() and map() to transform and combine their values.

Example:

package org.kodejava.util;

import java.util.Optional;

public class OptionalCombination {
    public static void main(String[] args) {
        Optional<String> optional1 = Optional.of("Hello");
        Optional<String> optional2 = Optional.of("World");

        Optional<String> combined = optional1.flatMap(val1 ->
                optional2.map(val2 -> val1 + " " + val2)
        );

        // Output: Hello World
        combined.ifPresent(System.out::println); 
    }
}

Here:

  • flatMap is used on the first Optional.
  • map is applied on the second Optional inside the flatMap block.
  • This ensures the operation occurs only if both Optionals are present.

2. Using Multiple Optionals Dynamically with Streams

If you have multiple Optional objects, a dynamic approach using streams may be more suitable.

Example:

package org.kodejava.util;

import java.util.Optional;
import java.util.stream.Stream;

public class OptionalCombinationWithStreams {
    public static void main(String[] args) {
        Optional<String> optional1 = Optional.of("Hello");
        Optional<String> optional2 = Optional.of("Functional");
        Optional<String> optional3 = Optional.of("Java");

        String result = Stream.of(optional1, optional2, optional3)
                .flatMap(Optional::stream)
                .reduce((s1, s2) -> s1 + " " + s2)
                .orElse("No values");

        // Output: Hello Functional Java
        System.out.println(result);
    }
}

Steps in this approach:

  1. Use Stream.of() to collect your Optional objects.
  2. Extract their values using flatMap(Optional::stream).
  3. Combine the values with reduce.

3. Getting the First Non-Empty Optional

Sometimes, you’re only interested in the first non-empty Optional. For this, you can use Optional.or(), which was introduced in Java 9.

Example:

package org.kodejava.util;

import java.util.Optional;

public class FirstNonEmptyOptional {
    public static void main(String[] args) {
        Optional<String> optional1 = Optional.empty();
        Optional<String> optional2 = Optional.of("Hello");
        Optional<String> optional3 = Optional.empty();

        Optional<String> firstPresent = optional1
                .or(() -> optional2)
                .or(() -> optional3);

        // Output: Hello
        firstPresent.ifPresent(System.out::println);
    }
}

4. Handling Custom Logic with Optionals

You can define custom logic to process multiple Optionals and combine them using a utility function when needed.

Example:

package org.kodejava.util;

import java.util.Optional;
import java.util.stream.Stream;
import java.util.stream.Collectors;

public class OptionalCustomCombination {
    public static void main(String[] args) {
        Optional<Integer> optional1 = Optional.of(10);
        Optional<Integer> optional2 = Optional.of(20);
        Optional<Integer> optional3 = Optional.empty();

        Optional<Integer> combined = combineOptionals(optional1, optional2, optional3);
        combined.ifPresent(System.out::println); // Output: 30
    }

    @SafeVarargs
    public static Optional<Integer> combineOptionals(Optional<Integer>... optionals) {
        return Stream.of(optionals)
                .flatMap(Optional::stream)
                .collect(Collectors.reducing(Integer::sum));
    }
}

In this example:

  • The combineOptionals method dynamically handles any number of Optional<Integer>.
  • Non-empty values are summed using Collectors.reducing().

Which Pattern Should You Use?

  • Combine Only When All Optionals Are Present: Use flatMap and map chaining.
  • Combine Dynamically with Multiple Optionals: Use a Stream.
  • Use First Non-Empty Optional: Use Optional.or().
  • Custom Processing Logic: Create a reusable utility method.

This way, you can handle Optional objects cleanly and avoid verbose null checks.

How do I filter Optional values based on a condition?

By I Wayan Saryada in Util Package 0 Comment

In Java, you can use the Optional API to filter values based on a condition using the filter method. The filter method takes a predicate as an argument and applies it to the value contained in the Optional. If the predicate evaluates to true, the Optional is returned unchanged. If the predicate evaluates to false, an empty Optional is returned.

Here’s an example:

Example:

package org.kodejava.util;

import java.util.Optional;

public class OptionalFilterExample {
   public static void main(String[] args) {
      // Create an Optional with a value
      Optional<String> optionalValue = Optional.of("hello");

      // Filter the Optional value based on a condition
      Optional<String> filteredValue = optionalValue.filter(value -> value.length() > 3);

      // If the value passes the filter, print it
      filteredValue.ifPresent(System.out::println); // Output: hello

      // Example where the filter does not match
      Optional<String> emptyValue = optionalValue.filter(value -> value.length() > 10);
      System.out.println(emptyValue.isPresent()); // Output: false
   }
}

Explanation:

  1. Initial Value: The Optional is created with the value "hello".
  2. Filtering: The filter method takes a predicate (value -> value.length() > 3) and applies it to the contained value.
    • If the predicate is true (length is greater than 3), the Optional retains the value.
    • If the predicate is false (e.g., length is less than 10), the result is an empty Optional.
  3. Accessing Results: The ifPresent method is used to print the value if it is still present, or use isPresent to evaluate if the result is empty.

Summary:

  • Use Optional.filter(Predicate<T>) to conditionally retain the value in an Optional.
  • If the predicate fails, the Optional becomes empty.
  • Combine Optional with ifPresent, isPresent, or orElse to handle the filtered result.

How do I use Optional to refactor nested null checks?

By I Wayan Saryada in Util Package 0 Comment

Using Optional in Java is a great way to refactor nested null checks into more readable and maintainable code. Below, I’ll explain how you can use Optional to replace deeply nested null checks step by step with examples.

Example of Nested Null Checks

Consider this code with deeply nested null checks:

String streetName = null;

if (user != null) {
    Address address = user.getAddress();
    if (address != null) {
        Street street = address.getStreet();
        if (street != null) {
            streetName = street.getName();
        }
    }
}

Here, multiple if statements are used to avoid NullPointerException. This can make the code verbose and harder to read.

Refactoring with Optional

You can refactor this using Optional to create a chain of operations that handle nulls more elegantly:

String streetName = Optional.ofNullable(user)
    .map(User::getAddress)  // get Address if user is not null
    .map(Address::getStreet) // get Street if Address is not null
    .map(Street::getName)    // get Name if Street is not null
    .orElse(null);           // return null if any step is null

This way, you eliminate the explicit null checks and reduce the overall complexity of the code.

Explanation of the Refactored Code

  • Optional.ofNullable(user)
    Wraps the user object in an Optional. If user is null, it creates an empty Optional to safely handle further processing.

  • .map()

    • Applies the method if the value is present; otherwise, it returns an empty Optional.
    • For example, map(User::getAddress) calls getAddress only if user is not null.
  • .orElse(null)
    Provides a fallback value in case the chain results in an empty Optional, i.e., if any intermediate object was null.

Variations

1. Provide a Default Value Instead of Null

You can replace null with any default value like this:

String streetName = Optional.ofNullable(user)
    .map(User::getAddress)
    .map(Address::getStreet)
    .map(Street::getName)
    .orElse("Default Street");

If user or any intermediate object is null, "Default Street" will be assigned to streetName.

2. Throw Exception if Value is Missing

String streetName = Optional.ofNullable(user)
    .map(User::getAddress)
    .map(Address::getStreet)
    .map(Street::getName)
    .orElseThrow(() -> new IllegalArgumentException("Street name not found!"));

This method will throw an exception if any object in the chain is null.

3. Perform an Action if Value Exists

You can perform a side effect or some action if the resulting value isn’t null:

Optional.ofNullable(user)
    .map(User::getAddress)
    .map(Address::getStreet)
    .map(Street::getName)
    .ifPresent(name -> System.out.println("Street: " + name));

This approach avoids the need to explicitly check equality with null.

Benefits of Using Optional for Null Checks

  1. Improved Readability:
    Eliminates nested if statements and reduces verbosity.

  2. Clear Intent:
    It’s evident that the code is handling potentially null objects.

  3. Avoid NullPointerException:
    Safeguards code without explicit null checks by the chaining mechanism.

  4. Encourages Functional Style:
    Methods like map, orElse, and ifPresent allow for a clean, declarative style of programming.

When Not to Use Optional

While Optional is a powerful tool, it’s not meant to replace all null checks. Avoid using Optional:

  1. For fields in entities/classes (use only for method return values).
  2. When null checks aren’t deeply nested (a simple if might be more appropriate).

With Optional, you get safer and cleaner null handling in your Java code, making it easier to maintain and debug!

How do I conditionally execute code with Optional’s ifPresent and ifPresentOrElse?

By I Wayan Saryada in Util Package 0 Comment

In Java, the Optional class provides methods for handling values that may or may not be present. The methods ifPresent and ifPresentOrElse are particularly useful for executing code conditionally based on whether a value is present in the Optional.

1. Using ifPresent

The ifPresent method executes a Consumer when the value is present (i.e., it’s not null). If the Optional is empty, it does nothing. This is useful when you only want to handle the presence of a value and don’t need any fallback action when the value is absent.

Example:

package org.kodejava.util;

import java.util.Optional;

public class OptionalIfPresentExample {
    public static void main(String[] args) {
        // Create an Optional with a value
        Optional<String> optionalValue = Optional.of("Hello, Optional!");

        // Execute only if a value is present
        optionalValue.ifPresent(value -> System.out.println("Value is: " + value));

        // Create an empty Optional
        Optional<String> emptyOptional = Optional.empty();

        // Nothing happens here
        emptyOptional.ifPresent(value -> System.out.println("This won't be printed."));
    }
}

Output:

Value is: Hello, Optional!

2. Using ifPresentOrElse

The ifPresentOrElse method executes a Consumer if the value is present, and executes a Runnable if the value is absent. This is helpful if you want to handle both cases (presence and absence) explicitly.

Example:

package org.kodejava.util;

import java.util.Optional;

public class OptionalIfPresentOrElseExample {
    public static void main(String[] args) {
        // Create an Optional with a value
        Optional<String> optionalValue = Optional.of("Hello, Optional!");

        // Execute the consumer if the value is present, otherwise execute the runnable
        optionalValue.ifPresentOrElse(
                value -> System.out.println("Value is: " + value),
                () -> System.out.println("Value is not present")
        );

        // Create an empty Optional
        Optional<String> emptyOptional = Optional.empty();

        // Handle the absence of value
        emptyOptional.ifPresentOrElse(
                value -> System.out.println("This won't be printed."),
                () -> System.out.println("Value is not present")
        );
    }
}

Output:

Value is: Hello, Optional!
Value is not present

Key Differences:

  1. ifPresent: Only executes when the value is present. It doesn’t account for the absent case.
  2. ifPresentOrElse: Handles both the presence and absence cases, allowing you to define fallback behavior when the value is missing.

Use case:

  • Use ifPresent when you only care about taking action if the value is present.
  • Use ifPresentOrElse when you also want to explicitly perform some alternate action if the value is absent.

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

By I Wayan Saryada 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.