Uso adequado de Optional.ifPresent ()

Estou tentando entender o ifPresent()método da OptionalAPI em Java 8.

Eu tenho uma lógica simples:

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

Mas isso resulta em um erro de compilação:

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

Claro que posso fazer algo assim:

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

Mas isso é exatamente como um nullcheque desordenado .

Se eu mudar o código para este:

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

O código está ficando mais sujo, o que me faz pensar em voltar ao nullcheque antigo .

Alguma ideia?

Optional<User>.ifPresent()leva Consumer<? super User>como argumento. Você está passando uma expressão cujo tipo é vazio. Então isso não compila.

Um Consumidor deve ser implementado como uma expressão lambda:

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

Ou ainda mais simples, usando uma referência de método:

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

Isso é basicamente a mesma coisa que

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

A ideia é que a doSomethingWithUser()chamada do método só seja executada se o usuário estiver presente. Seu código executa a chamada de método diretamente e tenta passar seu resultado vazio para ifPresent().

Além da resposta de @JBNizet, meu caso de uso geral para ifPresenté combinar .isPresent()e .get():

À moda antiga:

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

Nova forma:

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

Isso, para mim, é mais intuitivo.

Use flatMap. Se um valor estiver presente, flatMap retorna um Stream sequencial contendo apenas aquele valor; caso contrário, retorna um Stream vazio. Portanto, não há necessidade de usar ifPresent(). Exemplo:

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

Por que escrever um código complicado quando você pode torná-lo simples?

Na verdade, se você for absolutamente usar a Optionalclasse, o código mais simples é o que você já escreveu ...

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

Este código tem a vantagem de ser

1. legível
2. fácil de depurar (ponto de interrupção)
3. não é complicado

Só porque a Oracle adicionou a Optionalclasse em Java 8 não significa que essa classe deva ser usada em todas as situações.

Você pode usar a referência de método como este:

user.ifPresent(ClassNameWhereMethodIs::doSomethingWithUser);

O método ifPresent()get Consumerobject como um parâmetro e (de JavaDoc ): "Se um valor estiver presente, chame o consumidor especificado com o valor." Valor é a sua variável user.

Ou se este método doSomethingWithUserestiver na Userclasse e não estiver static, você pode usar a referência de método desta forma:

user.ifPresent(this::doSomethingWithUser);