Style fonctionnel d'Optionalif.ifPresent et if-not-Present de Java 8?

En Java 8, je veux faire quelque chose à un Optionalobjet s'il est présent, et faire autre chose s'il n'est pas présent.

if (opt.isPresent()) {
  System.out.println("found");
} else {
  System.out.println("Not found");
}

Ce n'est cependant pas un «style fonctionnel».

Optionala une ifPresent()méthode, mais je ne peux pas enchaîner une orElse()méthode.

Ainsi, je ne peux pas écrire:

opt.ifPresent( x -> System.out.println("found " + x))
   .orElse( System.out.println("NOT FOUND"));

En réponse à @assylias, je ne pense pas que cela Optional.map()fonctionne pour le cas suivant:

opt.map( o -> {
  System.out.println("while opt is present...");
  o.setProperty(xxx);
  dao.update(o);
  return null;
}).orElseGet( () -> {
  System.out.println("create new obj");
  dao.save(new obj);
  return null;
});

Dans ce cas, lorsqu'il optest présent, je mets à jour sa propriété et l'enregistre dans la base de données. Lorsqu'il n'est pas disponible, j'en crée un nouveau objet l'enregistre dans la base de données.

Remarque dans les deux lambdas je dois revenir null.

Mais quand il optest présent, les deux lambdas seront exécutés. objsera mis à jour et un nouvel objet sera enregistré dans la base de données. C'est à cause de return nullla première lambda. Et orElseGet()continuera à exécuter.

Pour moi, la réponse de @Dane White est OK, d'abord je n'ai pas aimé utiliser Runnable mais je n'ai trouvé aucune alternative, ici une autre implémentation que j'ai préféré plus

public class OptionalConsumer<T> {
    private Optional<T> optional;

    private OptionalConsumer(Optional<T> optional) {
        this.optional = optional;
    }

    public static <T> OptionalConsumer<T> of(Optional<T> optional) {
        return new OptionalConsumer<>(optional);
    }

    public OptionalConsumer<T> ifPresent(Consumer<T> c) {
        optional.ifPresent(c);
        return this;
    }

    public OptionalConsumer<T> ifNotPresent(Runnable r) {
        if (!optional.isPresent()) {
            r.run();
        }
        return this;
    }
}

Ensuite :

Optional<Any> o = Optional.of(...);
OptionalConsumer.of(o).ifPresent(s ->System.out.println("isPresent "+s))
            .ifNotPresent(() -> System.out.println("! isPresent"));

Mise à jour 1:

la solution ci-dessus pour le mode de développement traditionnel lorsque vous avez la valeur et que vous souhaitez la traiter mais que se passe-t-il si je veux définir la fonctionnalité et l'exécution sera alors, vérifiez l'amélioration ci-dessous;

public class OptionalConsumer<T> implements Consumer<Optional<T>> {
private final Consumer<T> c;
private final Runnable r;

public OptionalConsumer(Consumer<T> c, Runnable r) {
    super();
    this.c = c;
    this.r = r;
}

public static <T> OptionalConsumer<T> of(Consumer<T> c, Runnable r) {
    return new OptionalConsumer(c, r);
}

@Override
public void accept(Optional<T> t) {
    if (t.isPresent()) {
        c.accept(t.get());
    }
    else {
        r.run();
    }
}

Ensuite, pourrait être utilisé comme:

    Consumer<Optional<Integer>> c=OptionalConsumer.of(System.out::println, ()->{System.out.println("Not fit");});
    IntStream.range(0, 100).boxed().map(i->Optional.of(i).filter(j->j%2==0)).forEach(c);

Dans ce nouveau code, vous avez 3 choses:

1. peut définir une fonctionnalité avant d'exister facilement.
2. ne pas créer de réfraction d'objet pour chaque Facultatif, un seul, vous avez donc moins de mémoire que moins de GC.
3. il met en œuvre le consommateur pour une meilleure utilisation avec d'autres composants.

à propos maintenant son nom est plus descriptif, il est en fait consommateur>

Si vous utilisez Java 9+, vous pouvez utiliser la ifPresentOrElse()méthode:

opt.ifPresentOrElse(
   value -> System.out.println("Found: " + value),
   () -> System.out.println("Not found")
);

Java 9 présente

ifPresentOrElse si une valeur est présente, exécute l'action donnée avec la valeur, sinon exécute l'action basée sur le vide donnée.

Voir excellente feuille de triche facultative dans Java 8 .

Il fournit toutes les réponses pour la plupart des cas d'utilisation.

Bref résumé ci-dessous

ifPresent () - faire quelque chose lorsque Facultatif est défini

opt.ifPresent(x -> print(x)); 
opt.ifPresent(this::print);

filter () - rejeter (filtrer) certaines valeurs facultatives.

opt.filter(x -> x.contains("ab")).ifPresent(this::print);

map () - transforme la valeur si elle est présente

opt.map(String::trim).filter(t -> t.length() > 1).ifPresent(this::print);

orElse () / orElseGet () - tourner vide Facultatif à T par défaut

int len = opt.map(String::length).orElse(-1);
int len = opt.
    map(String::length).
    orElseGet(() -> slowDefault());     //orElseGet(this::slowDefault)

orElseThrow () - levée paresseuse des exceptions sur vide Facultatif

opt.
filter(s -> !s.isEmpty()).
map(s -> s.charAt(0)).
orElseThrow(IllegalArgumentException::new);

Une alternative est:

System.out.println(opt.map(o -> "Found")
                      .orElse("Not found"));

Je ne pense pas que cela améliore la lisibilité.

Ou comme l'a suggéré Marko, utilisez un opérateur ternaire:

System.out.println(opt.isPresent() ? "Found" : "Not found");

Une autre solution serait d'utiliser des fonctions d'ordre supérieur comme suit

opt.<Runnable>map(value -> () -> System.out.println("Found " + value))
   .orElse(() -> System.out.println("Not Found"))
   .run();

Il n'y a pas un excellent moyen de le faire hors de la boîte. Si vous souhaitez utiliser régulièrement votre syntaxe de nettoyage, vous pouvez créer une classe utilitaire pour vous aider:

public class OptionalEx {
    private boolean isPresent;

    private OptionalEx(boolean isPresent) {
        this.isPresent = isPresent;
    }

    public void orElse(Runnable runner) {
        if (!isPresent) {
            runner.run();
        }
    }

    public static <T> OptionalEx ifPresent(Optional<T> opt, Consumer<? super T> consumer) {
        if (opt.isPresent()) {
            consumer.accept(opt.get());
            return new OptionalEx(true);
        }
        return new OptionalEx(false);
    }
}

Ensuite, vous pouvez utiliser une importation statique ailleurs pour obtenir une syntaxe proche de ce que vous recherchez:

import static com.example.OptionalEx.ifPresent;

ifPresent(opt, x -> System.out.println("found " + x))
    .orElse(() -> System.out.println("NOT FOUND"));

Si vous ne pouvez utiliser que Java 8 ou une version antérieure:

1) si vous ne disposez pas spring-datadu meilleur moyen jusqu'à présent:

opt.<Runnable>map(param -> () -> System.out.println(param))
      .orElse(() -> System.out.println("no-param-specified"))
      .run();

Maintenant, je sais que ce n'est pas si lisible et même difficile à comprendre pour quelqu'un, mais ça me va bien personnellement et je ne vois pas une autre belle manière fluide pour ce cas.

2) si vous êtes assez chanceux et que vous pouvez utiliser spring-datale meilleur moyen est Optionals # ifPresentOrElse :

Optionals.ifPresentOrElse(opt, System.out::println,
      () -> System.out.println("no-param-specified"));

Si vous pouvez utiliser Java 9, vous devez absolument utiliser:

opt.ifPresentOrElse(System.out::println,
      () -> System.out.println("no-param-specified"));

Le comportement décrit peut être obtenu en utilisant Vavr (anciennement Javaslang), une bibliothèque fonctionnelle pour Java 8+, qui implémente la plupart des constructions Scala (Scala étant un langage plus expressif avec un système de type beaucoup plus riche basé sur JVM). C'est une très bonne bibliothèque à ajouter à vos projets Java pour écrire du code fonctionnel pur.

Vavr fournit la Optionmonade qui fournit des fonctions pour travailler avec le type d'option telles que:

• fold: pour mapper la valeur de l'option sur les deux cas (défini / vide)
• onEmpty: permet d'exécuter une Runnableoption quand est vide
• peek: permet de consommer la valeur de l'option (lorsqu'elle est définie).
• et c'est aussi Serializableau contraire Optionalce qui signifie que vous pouvez l'utiliser en toute sécurité comme argument de méthode et membre d'instance.

L'option suit les lois de la monade à la différence de la "pseudo-monade" facultative de Java et fournit une API plus riche. Et bien sûr, vous pouvez le faire à partir d'un Java facultatif (et Option.ofOptional(javaOptional)inversement ): –Vavr se concentre sur l'interopérabilité.

En passant à l'exemple:

// AWESOME Vavr functional collections (immutable for the gread good :)
// fully convertible to Java's counterparts.
final Map<String, String> map = Map("key1", "value1", "key2", "value2");

final Option<String> opt = map.get("nonExistentKey"); // you're safe of null refs!

final String result = opt.fold(
        () -> "Not found!!!",                // Option is None
        val -> "Found the value: " + val     // Option is Some(val)
);

Lectures complémentaires

Référence nulle, l'erreur d'un milliard de dollars

NB Ce n'est qu'un très petit exemple de ce que propose Vavr (correspondance de modèles, streams ou listes évaluées paresseuses, types monadiques, collections immuables, ...).

Une autre solution pourrait être la suivante:

Voici comment vous l'utilisez:

    final Opt<String> opt = Opt.of("I'm a cool text");
    opt.ifPresent()
        .apply(s -> System.out.printf("Text is: %s\n", s))
        .elseApply(() -> System.out.println("no text available"));

Ou dans le cas où vous dans le cas d'utilisation contraire est vrai:

    final Opt<String> opt = Opt.of("This is the text");
    opt.ifNotPresent()
        .apply(() -> System.out.println("Not present"))
        .elseApply(t -> /*do something here*/);

Ce sont les ingrédients:

1. Petite interface Function modifiée, juste pour la méthode "elseApply"
2. Amélioration facultative
3. Un peu de ronronnement :-)

L'interface de fonction améliorée "cosmétiquement".

@FunctionalInterface
public interface Fkt<T, R> extends Function<T, R> {

    default R elseApply(final T t) {
        return this.apply(t);
    }

}

Et la classe wrapper facultatif pour l'amélioration:

public class Opt<T> {

    private final Optional<T> optional;

    private Opt(final Optional<T> theOptional) {
        this.optional = theOptional;
    }

    public static <T> Opt<T> of(final T value) {
        return new Opt<>(Optional.of(value));
    }

    public static <T> Opt<T> of(final Optional<T> optional) {
        return new Opt<>(optional);
    }

    public static <T> Opt<T> ofNullable(final T value) {
        return new Opt<>(Optional.ofNullable(value));
    }

    public static <T> Opt<T> empty() {
        return new Opt<>(Optional.empty());
    }

    private final BiFunction<Consumer<T>, Runnable, Void> ifPresent = (present, notPresent) -> {
        if (this.optional.isPresent()) {
            present.accept(this.optional.get());
        } else {
            notPresent.run();
        }
        return null;
    };

   private final BiFunction<Runnable, Consumer<T>, Void> ifNotPresent = (notPresent, present) -> {
        if (!this.optional.isPresent()) {
            notPresent.run();
        } else {
            present.accept(this.optional.get());
        }
        return null;
    };

    public Fkt<Consumer<T>, Fkt<Runnable, Void>> ifPresent() {
        return Opt.curry(this.ifPresent);
    }

    public Fkt<Runnable, Fkt<Consumer<T>, Void>> ifNotPresent() {
        return Opt.curry(this.ifNotPresent);
    }

    private static <X, Y, Z> Fkt<X, Fkt<Y, Z>> curry(final BiFunction<X, Y, Z> function) {
        return (final X x) -> (final Y y) -> function.apply(x, y);
    }
}

Cela devrait faire l'affaire et pourrait servir de modèle de base pour gérer ces exigences.

L'idée de base ici est la suivante. Dans un monde de programmation de style non fonctionnel, vous implémenteriez probablement une méthode prenant deux paramètres où le premier est une sorte de code exécutable qui devrait être exécuté au cas où la valeur est disponible et l'autre paramètre est le code exécutable qui devrait être exécuté au cas où le la valeur n'est pas disponible. Dans un souci de meilleure lisibilité, vous pouvez utiliser le récurage pour diviser la fonction de deux paramètres en deux fonctions d'un paramètre chacune. C'est ce que j'ai essentiellement fait ici.

Astuce: Opt fournit également l'autre cas d'utilisation où vous souhaitez exécuter un morceau de code au cas où la valeur ne serait pas disponible. Cela pourrait être fait également via Optional.filter.stuff mais j'ai trouvé cela beaucoup plus lisible.

J'espère que cela pourra aider!

Bonne programmation :-)

Si vous souhaitez stocker la valeur:

Pair.of<List<>, List<>> output = opt.map(details -> Pair.of(details.a, details.b))).orElseGet(() -> Pair.of(Collections.emptyList(), Collections.emptyList()));

Supposons que vous ayez une liste et évitez le isPresent()problème (lié aux options) que vous pourriez utiliser .iterator().hasNext()pour vérifier s'il n'est pas présent.