Atalho para nula-check antes de invocação de método em java

Raphael Tarita:

Ao escrever simples ou código java complexo, parece bastante comum para escrever código como este:

if (obj != null) {
    obj.someMethod();
}

Ou mais específico:

Foo someValue = null;
if (valueObject != null) {
    someValue = valueObject.getSomeValue();
}

O que significaria someValueestadias nulo quando o objeto de valor é nulo. Agora, como eu encontrar esse tipo de código, muitas vezes (e que aumenta a complexidade cognitiva / cíclico), Gostaria de saber se há alguma maneira de simplificar essas declarações de forma alguma. Eu olhei para uma solução que parece:

Foo someValue = nullOrCompute(valueObject, valueObject::getSomeValue);

Depois de alguma pesquisa, parecia que Java não fornece um recurso semelhante. Então, como um teste, eu escrevi o atalho mim mesmo, que se parece com isso:

public class NullHelper
{
    private static <T> boolean check(T object)
    {
        return object == null;
    }

    public static <T> void nullOrExecute(T object, Consumer<T> func)
    {
        if (!check(object))
            func.accept(object);
    }

    public static <T, R> R nullOrCompute(T object, Function<T, R> func)
    {
        return check(object)
            ? null
            : func.apply(object);
    }

    public static <T, P0, R> R nullOrCompute(T object, BiFunction<T, P0, R> func, P0 param0)
    {
        return check(object)
            ? null
            : func.apply(object, param0);
    }

    // more params
}

Note que você tem que escrever seus próprios " NFunction" Interfaces se você queria incluir versões com mais parâmetros, porque Java não fornece TriFunctions ou superior.

Minha pergunta é:

este código é uma boa maneira de simplificar uma grande base de código existente? E se não, é porque há um recurso mais conveniente Java que eu não sei, ou é beacuse Preciso melhorar minha versão personalizada (e como)?

Tenha em mente que eu não estou falando sobre a solução mais conveniente em geral , mas para uma solução que pode ser aplicado a uma grande base de código existente.

Agradeço antecipadamente.

Malt:

Seu código:

check(foo)
nullOrExecute(foo, consumer)
nullOrCompute(foo, mapper)
nullOrCompute(foo, func, param)

código equivalente usando opcionais:

Optional.ofNullable(foo).isPresent();
Optional.ofNullable(foo).ifPresent(consumer);
Optional.ofNullable(foo).map(mapper)