Wie zurück, wenn eine optionale leer ist?

Ich Liebe es, dass Optionen sind in der Java-standard-Bibliothek. Aber es ist ein Grundsätzliches problem, das ich laufen in der ich noch nicht herausgefunden, wie zu lösen, in den besten (einfachsten zu Lesen und zu verstehen, schönsten, kürzesten) Weg:

Wie die Rückkehr aus einer Methode, wenn eine optionale leer ist?

Ich bin auf der Suche nach einer Allgemeinen Lösung, die Werke für verschiedene Kombinationen von zahlen von Optionen und Größen von code-Blöcken.

In den folgenden Beispielen werde ich versuchen zu zeigen, was ich meine:

void m1() {
    //When I get an optional:
    Optional<String> o = getOptional();

    //And want to return if it's empty
    if (!o.isPresent()) return;

    //In the whole rest of the method I have to call Optional.get 
    //every time I want the value:
    System.out.println(o.get());

    //Which is pretty ugly and verbose!
}


void m2() {
    //If I instead return null if a value is absent:
    String s = getNullabe();
    if (s == null) return;

    //Then I can use the value directly:
    System.out.println(s);
}

Diese Frage ist etwa, wie man die gute Seite der beiden obigen Beispiele: Der Typ sicher der optionalen und der Kürze der nullable-Typen.

Den rest der Beispiele veranschaulicht dies mehr.

void m3() {
    //If I on the other hand want to throw on empty that's pretty and compact:
    String s = getOptional()
        .orElseThrow(IllegalStateException::new);

    System.out.println(s);
}

void m4() {
    Optional<String> o = getOptional();
    if (!o.isPresent()) return;

    //I can of course declare a new variable for the un-optionalised string:
    String s = o.get();

    System.out.println(s);

    //But the old variable still remains in scope for the whole method 
    //which is ugly and annoying.
    System.out.println(o.get());
}


void m5() {
    //This is compact and maybe pretty in some ways:
    getOptional().ifPresent(s -> {
        System.out.println(s);

        //But the extra level of nesting is annoying and it feels 
        //wrong to write all the code in a big lambda.

        getOtherOptional().ifPresent(i -> {
            //Also, more optional values makes it really weird and 
            //pretty hard to read,  while with nullables I would 
            //get no extra nesting, it would looks good and be 
            //easy to read.
            System.out.println("i: " + i);

            //It doesn't work in all cases either way.
        });
    });
}


Optional<String> getOptional() {
    throw new UnsupportedOperationException();
}

Optional<Integer> getOtherOptional() {
    throw new UnsupportedOperationException();
}

String getNullabe() {
    throw new UnsupportedOperationException();
}

Wie kann ich die Rückgabe von einer Methode, wenn ein optionales leer ist, ohne get im rest der Methode, ohne zu erklären, eine extra variable, und ohne extra-levels von block verschachteln?

Oder wenn es nicht möglich ist, all das bekommen, was ist der beste Weg, um mit dieser situation umzugehen?

InformationsquelleAutor Lii | 2016-06-27