Use Java Optional to refactor null check

What I am trying to achieve:

Use Java Optional to refactor null check.

Background:

I have a straightforward POJO class:

public record MyPojo(String someField, String someOtherField)

And this method:

    private static String question(final MyPojo mypojo) {
        if (null == mypojo) {
            return null;
        } else if (null == mypojo.someField()) {
            return null;
        } else {
            return mypojo.someField().toLowerCase();
        }
    }

Issue:

As you can see, while super easy to understand, this code is very verbose and lengthy.
MyPojo can be bull, and so can MyPojo.someField.
I need to check those two preconditions before applying my business logic (here lower case just for example)

Question:

Is there a smarter way, either using Optional, or something smarter, to refactor this?

You can chain your optional with .map() calls, the advantage of this approach is that it chains the operations together in a readable way and eliminates the need for explicit null checks:

private static String question(final MyPojo mypojo) {
    return Optional.ofNullable(mypojo)
              .map(MyPojo::someField)
              .map(String::toLowerCase)
              .orElse(null);
}

The old fashioned way is with the ? : operators:

    private static String question(final MyPojo mypojo) {
        return (null == mypojo) ? null
            : (null == mypojo.someField()) ? null
            : mypojo.someField().toLowerCase();
    }

First change the record:

public record MyPojo( String someField, String someOtherField )
{
    public MyPojo
    {
        Objects.requireNonNull( someField );
        Objects.requireNonNull( someOtherField );
    }
}

This ensures that the attributes are never null.

Then question() can look like this:

private static String question( final MyPojo mypojo ) 
{
    return Objects.nonNull( myPojo ) 
        ? myPojo.someField().toLowerCase() 
        : null;
}

If null should be allowed and you insist to use Optional, you need to modify the Pojo like this:

public final class MyPojo
{
    private final String m_SomeField;
    private final String m_SomeOtherField;
    public MyPojo( String someField, String someOtherField )
    {
        m_SomeField = someField;
        m_SomeOtherField = someOtherField;
    }

    public final Optional<String> someField() {return Optional.ofNullable( m_SomeField ); }
    …
}

question() would look like this afterwards:

private static String question( final MyPojo mypojo ) 
{
    return Objects.nonNull( myPojo ) 
        ? myPojo.someField().map( String::toLowerCase() ).orElse( null ) 
        : null;
}

The approach suggested in this answer works, but it is strongly discouraged to abuse Optional in this way as a replacement for if-then-else or ?-:. See here as one reference:

> Another mistake is misusing Optional and treating it as a replacement for conditional statements. Although Optional provides convenient methods like orElse() and orElseGet() to handle the absence of a value, using them excessively can lead to less readable code. It is important to remember that Optional is not intended to replace traditional if-else statements. Instead, it should be used when the absence of a value is a valid and expected outcome.
>
> […]
>
> […] Adhering to best practices such as preferring Optional as a method return type […] will enhance the readability and maintainability of your code.