Style fonctionnel de Java 8 est Facultatif.ifPresent et si n'est pas Présent?

Pour moi, la réponse de @Dane Blanc est OK, d'abord, je n'aime pas utiliser l'Exécutable, mais je ne pouvais pas trouver toutes les solutions de rechange, voici une autre application 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;
    }
}

Alors :

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 traditionnel de développement quand vous avez de la valeur et à traiter, mais ce que si je veux définir la fonctionnalité et l'exécution sera ensuite, vérifiez ci-dessous d'amélioration;

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();
    }
}

Pourrait alors ê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. pouvez définir les fonctionnalités avant d'objet facile.
2. ne pas créer d'objet de refrence pour chaque Option, un seul,vous avez donc moins de mémoire, puis de moins en moins GC.
3. c'est la mise en œuvre des consommateurs pour une meilleure utilisation avec d'autres composants.

par la façon dont aujourd'hui son nom est plus descriptive, il est effectivement Consommateur>

Voir excellent En option dans Java 8 feuille de triche.

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

Bref résumé ci-dessous

ifPresent() - faire quelque chose lorsque l'Option est réglée

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

filtre() - rejet (à filtre) certaines valeurs Optionnelles.

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

map () de transformation de la valeur si elle est présente

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

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

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

orElseThrow() - paresseusement lancer des exceptions à vide en Option

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

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();

Si vous ne pouvez utiliser que Java 8 ou moins:

1) si vous n'avez pas spring-data le meilleur moyen à ce jour est:

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

Maintenant, je sais que c'est pas si lisible et même difficile à comprendre pour quelqu'un, mais semble bien pour moi, personnellement, et je ne vois pas une autre belle couramment façon pour ce cas.

2) si vous êtes assez chanceux et vous pouvez utiliser spring-data la meilleure façon est
Options#ifPresentOrElse:

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

Si vous pouvez utiliser Java 9, vous devriez certainement aller avec:

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

Une autre solution pourrait être la suivante:

C'est la façon dont vous l'utiliser:

    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 de la face de cas d'utilisation 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. Peu modifiée de la Fonction de l'interface, juste pour le "elseApply" méthode
2. Amélioration facultative
3. Un peu de curring 🙂

La "cosmétiquement" Fonction améliorée de l'interface.

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

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

}

Et l'Option classe wrapper pour la mise en valeur:

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, la façon de traiter avec de telles exigences.

L'idée de base ici est la suivante. Dans un non fonctionnel de style de programmation monde vous serait probablement mettre en œuvre une méthode prenant deux paramètres où le premier est une sorte de code exécutable qui doit être exécutée dans le cas où la valeur est disponible et l'autre paramètre est l'exécutable, code qui doit être exécuté dans le cas où la valeur n'est pas disponible. Pour des raisons de meilleure lisibilité, vous pouvez utiliser curring de scinder la fonction de deux paramètres dans deux fonctions d'un paramètre. C'est ce que je faisait ici.

Conseil: Opter fournit également les autres cas d'utilisation où vous voulez exécuter un morceau de code, juste au cas où la valeur n'est pas disponible. Cela peut être aussi fait via une Option.le filtre.des trucs, mais je trouve cela beaucoup plus lisible.

Espère que ça aide!

Bonne programmation 🙂

En supposant que vous avez une liste et en évitant les isPresent() question (en rapport avec options) que vous pouvez utiliser .iterator().hasNext() pour vérifier si pas présent.