Uso corretto di Optional.ifPresent ()

Sto cercando di capire il ifPresent()metodo diOptional dell'API in Java 8.

Ho una logica semplice:

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

Ma questo si traduce in un errore di compilazione:

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

Ovviamente posso fare qualcosa del genere:

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

Ma questo è esattamente come un nullassegno disordinato .

Se cambio il codice in questo:

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

Il codice si sta sporcando, il che mi fa pensare di tornare al vecchio nullcontrollo.

Qualche idea?

Optional<User>.ifPresent()accetta un Consumer<? super User>argomento. Stai passando un'espressione il cui tipo è nullo. Quindi non viene compilato.

Un consumatore è pensato per essere implementato come espressione lambda:

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

O ancora più semplice, utilizzando un metodo di riferimento:

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

Questa è fondamentalmente la stessa cosa di

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

L'idea è che la doSomethingWithUser()chiamata al metodo verrà eseguita solo se l'utente è presente. Il codice esegue direttamente la chiamata al metodo e cerca di passare il risultato void a ifPresent().

Oltre alla risposta di @ JBNizet, il mio caso d'uso generale per ifPresentè combinare .isPresent()e.get() :

Vecchio modo:

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

Nuovo modo:

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

Questo, per me, è più intuitivo.

Perché scrivere codice complicato quando potresti renderlo semplice?

In effetti, se intendi assolutamente utilizzare la Optionalclasse, il codice più semplice è quello che hai già scritto ...

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

Questo codice ha i vantaggi di essere

1. leggibile
2. facile da eseguire il debug (punto di interruzione)
3. non complicato

Solo perché Oracle ha aggiunto la Optionalclasse in Java 8 non significa che questa classe debba essere utilizzata in tutte le situazioni.

Usa flatMap. Se è presente un valore, flatMap restituisce un flusso sequenziale contenente solo quel valore, altrimenti restituisce un flusso vuoto. Quindi non è necessario utilizzare ifPresent(). Esempio:

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

Puoi usare il metodo di riferimento in questo modo:

user.ifPresent(ClassNameWhereMethodIs::doSomethingWithUser);

Il metodo ifPresent()ottiene l' Consumeroggetto come parametro e (da JavaDoc ): "Se è presente un valore, richiama il consumatore specificato con il valore." Valore è la tua variabileuser .

O se questo metodo doSomethingWithUserè nella Userclasse e non lo è static, puoi usare il metodo di riferimento in questo modo:

user.ifPresent(this::doSomethingWithUser);