Utilisation correcte de Optional.ifPresent ()

J'essaie de comprendre la ifPresent()méthode de l' OptionalAPI dans Java 8.

J'ai une logique simple:

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

Mais cela entraîne une erreur de compilation:

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

Bien sûr, je peux faire quelque chose comme ça:

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

Mais c'est exactement comme un nullchèque encombré .

Si je change le code en ceci:

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

Le code est de plus en plus sale, ce qui me fait penser à revenir à l'ancien nullchèque.

Des idées?

Optional<User>.ifPresent()prend un Consumer<? super User>comme argument. Vous lui passez une expression dont le type est nul. Donc cela ne compile pas.

Un consommateur est destiné à être implémenté en tant qu'expression lambda:

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

Ou encore plus simple, en utilisant une référence de méthode:

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

C'est fondamentalement la même chose que

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

L'idée est que l' doSomethingWithUser()appel de méthode ne sera exécuté que si l'utilisateur est présent. Votre code exécute directement l'appel de méthode et tente de transmettre son résultat void à ifPresent().

En plus de la réponse de @ JBNizet, mon cas d'utilisation général ifPresentest de combiner .isPresent()et .get():

Ancienne façon:

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

Nouvelle façon:

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

Ceci, pour moi, est plus intuitif.

Pourquoi écrire du code compliqué alors que vous pouviez le simplifier?

En effet, si vous allez absolument utiliser la Optionalclasse, le code le plus simple est celui que vous avez déjà écrit ...

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

Ce code présente les avantages d'être

1. lisible
2. facile à déboguer (point d'arrêt)
3. pas compliqué

Ce Optionaln'est pas parce qu'Oracle a ajouté la classe dans Java 8 que cette classe doit être utilisée dans toutes les situations.

Utilisez flatMap. Si une valeur est présente, flatMap renvoie un Stream séquentiel contenant uniquement cette valeur, sinon renvoie un Stream vide. Il n'y a donc pas besoin d'utiliser ifPresent(). Exemple:

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

Vous pouvez utiliser une référence de méthode comme celle-ci:

user.ifPresent(ClassNameWhereMethodIs::doSomethingWithUser);

Méthode ifPresent()get Consumerobject comme paramètre et (à partir de JavaDoc ): "Si une valeur est présente, invoquez le consommateur spécifié avec la valeur." Value it est votre variable user.

Ou si cette méthode doSomethingWithUserest dans la Userclasse et qu'elle ne l'est pas static, vous pouvez utiliser une référence de méthode comme celle-ci:

user.ifPresent(this::doSomethingWithUser);