Java 8 optional: ifPresent-Rückgabeobjekt oder ElseThrow-Ausnahme

Ich versuche so etwas zu machen:

 private String getStringIfObjectIsPresent(Optional<Object> object){
        object.ifPresent(() ->{
            String result = "result";
            //some logic with result and return it
            return result;
        }).orElseThrow(MyCustomException::new);
    }

Dies wird nicht funktionieren, da ifPresent die Consumer-Funktionsschnittstelle als Parameter verwendet, die void accept(T t) hat. Es kann keinen Wert zurückgeben. Gibt es eine andere Möglichkeit, es zu tun?

Eigentlich suchst du: Optional.map. Ihr Code würde dann so aussehen:

object.map(o -> "result" /* or your function */)
      .orElseThrow(MyCustomException::new);

Auf das Weitergeben würde ich lieber verzichten Optional falls Sie können. Am Ende gewinnen Sie nichts mit einem Optional hier. Eine etwas andere Variante:

public String getString(Object yourObject) {
  if (Objects.isNull(yourObject)) { // or use requireNonNull instead if NullPointerException suffices
     throw new MyCustomException();
  }
  String result = ...
  // your string mapping function
  return result;
}

Wenn Sie die bereits haben Optional-Objekt Aufgrund eines anderen Anrufs würde ich dir trotzdem empfehlen, das zu verwenden map-Methode, statt isPresentetc. aus dem einzigen Grund, dass ich es lesbarer finde (eindeutig eine subjektive Entscheidung ;-)).

Hier zwei Möglichkeiten:

Ersetzen ifPresent mit map und verwenden Function Anstatt von Consumer

private String getStringIfObjectIsPresent(Optional<Object> object) {
    return object
            .map(obj -> {
                String result = "result";
                //some logic with result and return it
                return result;
            })
            .orElseThrow(MyCustomException::new);
}

Verwenden isPresent:

private String getStringIfObjectIsPresent(Optional<Object> object) {
    if (object.isPresent()) {
        String result = "result";
        //some logic with result and return it
        return result;
    } else {
        throw new MyCustomException();
    }
}

Verwenden Sie die map-Funktion stattdessen. Es transformiert den Wert innerhalb des optionalen.

So was:

private String getStringIfObjectIsPresent(Optional<Object> object) {
    return object.map(() -> {
        String result = "result";
        //some logic with result and return it
        return result;
    }).orElseThrow(MyCustomException::new);
}

Ich bevorzuge die Zuordnung, nachdem ich sichergestellt habe, dass der Wert verfügbar ist

private String getStringIfObjectIsPresent(Optional<Object> object) {
   Object ob = object.orElseThrow(MyCustomException::new);
    // do your mapping with ob
   String result = your-map-function(ob);
  return result;
}

oder ein Liner

private String getStringIfObjectIsPresent(Optional<Object> object) {
   return your-map-function(object.orElseThrow(MyCustomException::new));
}

Das Beispiel, das Sie nennen, ist kein gutes Beispiel. Optional sollte nicht als Parameter an eine andere Funktion gesendet werden. Gute Praxis ist immer das Senden von Nicht-Null-Parametern an die Funktion. Damit wir immer wissen, dass die Eingabe nicht null sein wird. Dies kann unsere Code-Unsicherheit verringern.