Verkettung von Optionalen in Java 8

Suche nach einem Weg, um die Kette Optionen, so dass die erste eine, die vorhanden ist, wird zurückgegeben. Wenn keine vorhanden sind Optional.empty() zurückgegeben werden soll.

Vorausgesetzt, ich habe mehrere Methoden wie diese:

Optional<String> find1()

Ich versuche, die Kette Sie:

Optional<String> result = find1().orElse( this::find2 ).orElse( this::find3 );

aber natürlich nicht funktioniert, da orElse einen Wert erwartet und orElseGet erwartet eine Supplier.

InformationsquelleAutor der Frage piler | 2015-02-14

Verwenden Stream:

Stream.of(find1(), find2(), find3())
    .filter(Optional::isPresent)
    .map(Optional::get)
    .findFirst();

Wenn Sie brauchen, um zu bewerten die Methoden träge, verwenden Lieferanten Funktionen:

Stream.of(this::find1, this::find2, this::find3)
    .map(Supplier::get)
    .filter(Optional::isPresent)
    .map(Optional::get)
    .findFirst();

InformationsquelleAutor der Antwort Sauli Tähkäpää

Könnte man es so machen:

Optional<String> resultOpt = Optional.of(find1()
                                .orElseGet(() -> find2()
                                .orElseGet(() -> find3()
                                .orElseThrow(() -> new WhatEverException()))));

Aber ich bin mir nicht sicher, ob es die Lesbarkeit verbessert IMO. Guava bietet eine Möglichkeit zur Kette Optionen:

import com.google.common.base.Optional;

Optional<String> resultOpt = s.find1().or(s.find2()).or(s.find3());

Könnte es sein eine alternative für Ihr problem, aber nicht die standard-Optional-Klasse im JDK.

Wenn Sie möchten, um die standard-API, die Sie schreiben, könnte eine simple utility-Methode:

static <T> Optional<T> or(Optional<T> first, Optional<T> second) {
    return first.isPresent() ? first : second;
}

dann:

Optional<String> resultOpt = or(s.find1(), or(s.find2(), s.find3()));

Wenn Sie eine Menge von Optionen zu Ketten, vielleicht ist es besser, verwenden Sie die Stream-Ansatz als andere wissen schon.

InformationsquelleAutor der Antwort Alexis C.

13

Inspiriert von Sauli Antwort, ist es möglich, die flatMap() Methode.
```
Stream.of(this::find1, this::find2, this::find3)
  .map(Supplier::get)
  .flatMap(o -> o.map(Stream::of).orElseGet(Stream::empty))
  .findFirst();
```
Konvertieren Optional in einen Stream ist zu umständlich. Anscheinend ist dieses gehen zu sein Feste mit JDK9. Also das könnte so geschrieben werden, als
```
Stream.of(this::find1, this::find2, this::find3)
  .map(Supplier::get)
  .flatMap(Optional::stream)
  .findFirst();
```
Nach einem Java-Update 9 veröffentlicht wurde

Obwohl die ursprüngliche Frage war über Java 8, Optional::oder war eingeführt in Java 9. Mit es, das problem konnte wie folgt gelöst
```
Optional<String> result = find1()
  .or(this::find2)
  .or(this::find3);
```
InformationsquelleAutor der Antwort Indrek Ots
0

Durchführen Optional Chaining Ersten konvertieren - Stream-Optional Mit einer der beiden Methoden
1. findAny() oder findFirst()
2. min() /max()
Einmal optional erhalten wird, optional zwei weitere Instanz-Methode, die auch in der Stream-Klasse ich.e-filter und map().
verwenden Sie diese Verfahren und Methoden zu prüfen, die Ausgabe verwenden ifPresent(System.out :: Println)

ex:

Stream s = Stream.(1,2,3,4);

s.findFirst().filter((a)->a+1).ifPresent(System.out :: Println)

Ausgabe : 2

InformationsquelleAutor der Antwort Adit chandel

-3

Vielleicht einer von

    public <T> Optional<? extends T> firstOf(Optional<? extends T> first, @SuppressWarnings("unchecked") Supplier<Optional<? extends T>>... supp) {
        if (first.isPresent()) return first;
        for (Supplier<Optional <? extends T>> sup : supp) {
            Optional<? extends T> opt = sup.get();
            if (opt.isPresent()) {
                return opt;
            }
        }
        return Optional.empty();
    }

    public <T> Optional<? extends T> firstOf(Optional<? extends T> first, Stream<Supplier<Optional<? extends T>>> supp) {
        if (first.isPresent()) return first;
        Stream<Optional<? extends T>> present = supp.map(Supplier::get).filter(Optional::isPresent);
        return present.findFirst().orElseGet(Optional::empty);
    }

tun.

Die erste iteriert über ein array von Lieferanten. Die erste nicht-leere Optional<> zurückgegeben. Wenn wir nicht finden, kehren wir ein leeres Optional.

Die zweite macht das gleiche mit einem Stream von Suppliers die Durchlaufen wird, fragte jeder (aus Faulheit) für Wert, die dann gefiltert leer Optionals. Die erste nicht-leere zurückgegeben wird, oder, wenn keine solche existiert, wird eine leere ein.

InformationsquelleAutor der Antwort glglgl

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.