Uso adecuado de Optional.ifPresent ()

Estoy tratando de comprender el ifPresent()método de laOptional API en Java 8.

Tengo una lógica simple:

Optional<User> user=...
user.ifPresent(doSomethingWithUser(user.get()));

Pero esto resulta en un error de compilación:

ifPresent(java.util.functionError:(186, 74) java: 'void' type not allowed here)

Por supuesto que puedo hacer algo como esto:

if(user.isPresent())
{
  doSomethingWithUser(user.get());
}

Pero esto es exactamente como un desordenado null cheque .

Si cambio el código a esto:

 user.ifPresent(new Consumer<User>() {
            @Override public void accept(User user) {
                doSomethingWithUser(user.get());
            }
        });

El código se está volviendo más sucio, lo que me hace pensar en volver al antiguo null cheque anterior.

¿Algunas ideas?

Optional<User>.ifPresent()toma Consumer<? super User>como argumento. Le está pasando una expresión cuyo tipo es nulo. Entonces eso no se compila.

Se pretende que un consumidor se implemente como una expresión lambda:

Optional<User> user = ...
user.ifPresent(theUser -> doSomethingWithUser(theUser));

O incluso más simple, usando una referencia de método:

Optional<User> user = ...
user.ifPresent(this::doSomethingWithUser);

Esto es básicamente lo mismo que

Optional<User> user = ...
user.ifPresent(new Consumer<User>() {
    @Override
    public void accept(User theUser) {
        doSomethingWithUser(theUser);
    }
});

La idea es que la doSomethingWithUser()llamada al método solo se ejecute si el usuario está presente. Su código ejecuta la llamada al método directamente e intenta pasar su resultado nulo a ifPresent().

Además de la respuesta de @ JBNizet, mi caso de uso general ifPresentes combinar .isPresent()y.get() :

Vieja forma:

Optional opt = getIntOptional();
if(opt.isPresent()) {
    Integer value = opt.get();
    // do something with value
}

Nueva manera:

Optional opt = getIntOptional();
opt.ifPresent(value -> {
    // do something with value
})

Esto, para mí, es más intuitivo.

¿Por qué escribir código complicado cuando podrías hacerlo simple?

De hecho, si absolutamente va a utilizar la Optionalclase, el código más simple es el que ya ha escrito ...

if (user.isPresent())
{
    doSomethingWithUser(user.get());
}

Este código tiene las ventajas de ser

1. legible
2. fácil de depurar (punto de interrupción)
3. no es complicado

El hecho de que Oracle haya agregado la Optionalclase en Java 8 no significa que esta clase deba usarse en todas las situaciones.

Utilice flatMap. Si hay un valor presente, flatMap devuelve una secuencia secuencial que contiene solo ese valor; de lo contrario, devuelve una secuencia vacía. Entonces no hay necesidad de usar ifPresent(). Ejemplo:

list.stream().map(data -> data.getSomeValue).map(this::getOptinalValue).flatMap(Optional::stream).collect(Collectors.toList());

Puede usar una referencia de método como esta:

user.ifPresent(ClassNameWhereMethodIs::doSomethingWithUser);

El método ifPresent()obtiene el Consumerobjeto como parámetro y (de JavaDoc ): "Si hay un valor, invoca al consumidor especificado con el valor". Valora es tu variable user.

O si este método doSomethingWithUserestá en la Userclase y no lo está static, puede usar una referencia de método como esta:

user.ifPresent(this::doSomethingWithUser);