Atajo para null-cheque antes de invocación de método en java

Raphael Tarita:

Al escribir el código de Java simple o compleja, parece bastante común escribir código como este:

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

O más específica:

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

Lo que significaría someValueestancias nula cuando el valor del objeto es nulo. Ahora, como me encuentro con este tipo de código con bastante frecuencia (y aumenta la complejidad cognitiva / cíclico), me preguntaba si hay alguna manera de simplificar estas declaraciones en ninguna forma. Busqué una solución que se parece a:

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

Después de algunas investigaciones, parecía que Java no proporciona una característica similar. Por lo tanto, como una prueba, escribí el acceso directo a mí mismo, que se ve así:

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
}

Tenga en cuenta que tendría que escribir sus propios " NFunction" Interfaces si desea incluir versiones con más params porque Java no proporciona TriFunctions o superior.

Mi pregunta es:

Es el código de una buena manera de simplificar una gran base de código existente? Y si no es así, es porque no hay una forma más cómoda función de Java, que no sé, o es porque necesito mejorar mi versión personalizada (y cómo)?

Por favor, tenga en cuenta que no estoy hablando de la solución más conveniente , en general , pero para una solución que se puede aplicar a una gran base de código existente.

Gracias de antemano.

malta:

Tu codigo:

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

código equivalente usando opcionales:

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