Funktionsstil von Java 8 Optional.ifPresent und if-not-Present?

In Java 8 möchte ich etwas mit einem OptionalObjekt tun, wenn es vorhanden ist, und etwas anderes tun, wenn es nicht vorhanden ist.

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

Dies ist jedoch kein "funktionaler Stil".

Optionalhat eine ifPresent()Methode, aber ich kann keine orElse()Methode verketten.

Daher kann ich nicht schreiben:

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

Als Antwort auf @assylias denke ich nicht, dass dies Optional.map()für den folgenden Fall funktioniert:

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

In diesem Fall optaktualisiere ich , wenn vorhanden, seine Eigenschaft und speichere in der Datenbank. Wenn es nicht verfügbar ist, erstelle ich eine neue objund speichere sie in der Datenbank.

Beachten Sie in den beiden Lambdas, dass ich zurückkehren muss null.

Aber wenn optvorhanden, werden beide Lambdas ausgeführt. objwird aktualisiert und ein neues Objekt wird in der Datenbank gespeichert. Dies liegt am return nullim ersten Lambda. Und orElseGet()wird weiterhin ausgeführt.

Für mich ist die Antwort von @Dane White OK, zuerst mochte ich Runnable nicht, aber ich konnte keine Alternativen finden, hier eine andere Implementierung, die ich mehr bevorzugte

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

Dann :

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

Update 1:

Die obige Lösung für die traditionelle Art der Entwicklung, wenn Sie den Wert haben und ihn verarbeiten möchten, aber was ist, wenn ich die Funktionalität und die Ausführung definieren möchte, überprüfen Sie unten die Verbesserung.

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

Dann könnte verwendet werden als:

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

In diesem neuen Code haben Sie 3 Dinge:

1. kann Funktionalität definieren, bevor das Objekt einfach existiert.
2. Wenn Sie keine Objektreferenz für jede Option erstellen, nur eine, haben Sie so weniger Speicher als weniger GC.
3. Es implementiert Consumer für eine bessere Verwendung mit anderen Komponenten.

Übrigens ist sein Name jetzt aussagekräftiger, er ist tatsächlich Verbraucher>

Wenn Sie Java 9+ verwenden, können Sie folgende ifPresentOrElse()Methode verwenden:

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

Java 9 wird eingeführt

ifPresentOrElse führt, wenn ein Wert vorhanden ist, die angegebene Aktion mit dem Wert aus, andernfalls führt die angegebene leere Aktion aus.

Siehe ausgezeichnet Optional in Java 8 Spickzettel .

Es bietet alle Antworten für die meisten Anwendungsfälle.

Kurze Zusammenfassung unten

ifPresent () - etwas tun, wenn Optional eingestellt ist

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

filter () - bestimmte optionale Werte ablehnen (herausfiltern).

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

map () - Wert transformieren, falls vorhanden

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

orElse () / orElseGet () - leer werden Optional auf Standard T.

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

orElseThrow () - träge Ausnahmen auf leer werfen Optional

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

Eine Alternative ist:

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

Ich denke nicht, dass es die Lesbarkeit verbessert.

Oder verwenden Sie, wie von Marko vorgeschlagen, einen ternären Operator:

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

Eine andere Lösung wäre, Funktionen höherer Ordnung wie folgt zu verwenden

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

Es gibt keine großartige Möglichkeit, dies sofort zu tun. Wenn Sie Ihre Cleaner-Syntax regelmäßig verwenden möchten, können Sie eine Utility-Klasse erstellen, um Folgendes zu unterstützen:

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

Dann können Sie einen statischen Import an anderer Stelle verwenden, um eine Syntax zu erhalten, die genau dem entspricht, wonach Sie suchen:

import static com.example.OptionalEx.ifPresent;

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

Wenn Sie nur Java 8 oder niedriger verwenden können:

1) Wenn Sie bisher nicht spring-dataden besten Weg haben, ist:

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

Jetzt weiß ich, dass es für jemanden nicht so lesbar und sogar schwer zu verstehen ist, aber für mich persönlich sieht es gut aus und ich sehe keinen anderen schönen fließenden Weg für diesen Fall.

2) Wenn Sie Glück haben und spring-dataden besten Weg nutzen können , ist Optionals # ifPresentOrElse :

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

Wenn Sie Java 9 verwenden können, sollten Sie auf jeden Fall Folgendes wählen:

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

Das beschriebene Verhalten kann mit erreicht werden Vavr (früher bekannt als Javaslang) erreicht werden, einer objektfunktionalen Bibliothek für Java 8+, die die meisten Scala-Konstrukte implementiert (Scala ist eine ausdrucksstärkere Sprache mit einem wesentlich umfangreicheren Typsystem, das auf JVM basiert). Es ist eine sehr gute Bibliothek, die Sie zu Ihren Java-Projekten hinzufügen können, um reinen Funktionscode zu schreiben.

Vavr bietet die OptionMonade, die Funktionen für die Arbeit mit dem Optionstyp bereitstellt , z.

• fold: um den Wert der Option in beiden Fällen zuzuordnen (definiert / leer)
• onEmpty: Ermöglicht die Ausführung einer RunnableWhen-Option, wenn diese leer ist
• peek: Ermöglicht die Verwendung des Werts der Option (falls definiert).
• und es ist auch Serializableim Gegenteil, Optionalwas bedeutet, dass Sie es sicher als Methodenargument und Instanzmitglied verwenden können.

Option folgt den Monadengesetzen, die sich von der optionalen "Pseudo-Monade" von Java unterscheiden, und bietet eine umfangreichere API. Und natürlich können Sie es aus einem Java-Optional (und umgekehrt) machen:Option.ofOptional(javaOptional) –Vavr konzentriert sich auf Interoperabilität.

Zum Beispiel gehen:

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

Weiterführende Literatur

Null Referenz, der Milliarden-Dollar-Fehler

NB Dies ist nur ein sehr kleines Beispiel für das, was Vavr bietet (Mustervergleich, Streams, auch bekannt als faul bewertete Listen, monadische Typen, unveränderliche Sammlungen, ...).

Eine andere Lösung könnte sein:

So verwenden Sie es:

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

Oder falls Sie im Falle des entgegengesetzten Anwendungsfalls wahr sind:

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

Dies sind die Zutaten:

1. Wenig modifizierte Funktionsschnittstelle, nur für die "elseApply" -Methode
2. Optionale Erweiterung
3. Ein bisschen Curring :-)

Die "kosmetisch" verbesserte Funktionsschnittstelle.

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

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

}

Und die optionale Wrapper-Klasse zur Verbesserung:

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

Dies sollte den Trick tun und könnte als grundlegende Vorlage für den Umgang mit solchen Anforderungen dienen.

Die Grundidee hier folgt. In einer nicht funktionalen Programmierwelt würden Sie wahrscheinlich eine Methode implementieren, die zwei Parameter verwendet, wobei der erste eine Art ausführbarer Code ist, der ausgeführt werden sollte, wenn der Wert verfügbar ist, und der andere Parameter der ausführbare Code ist, der ausgeführt werden sollte, wenn der Wert ist nicht verfügbar. Zur besseren Lesbarkeit können Sie die Funktion von zwei Parametern mithilfe von curring in zwei Funktionen mit jeweils einem Parameter aufteilen. Das habe ich hier im Grunde getan.

Hinweis: Opt bietet auch den anderen Anwendungsfall, in dem Sie einen Code ausführen möchten, falls der Wert nicht verfügbar ist. Dies könnte auch über Optional.filter.stuff erfolgen, aber ich fand dies viel besser lesbar.

Ich hoffe, das hilft!

Gute Programmierung :-)

Falls Sie den Wert speichern möchten:

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

Angenommen, Sie haben eine Liste und vermeiden das isPresent()Problem (im Zusammenhang mit Optionen), mit dem Sie .iterator().hasNext()überprüfen können, ob es nicht vorhanden ist.