Jak powrócić, gdy opcja jest pusta?

Question

Uwielbiam to, że optionals są teraz w standardowej bibliotece Java. Ale pojawia się jeden podstawowy problem, na który nie mam pojęcia, jak rozwiązać problem w najlepszy (najłatwiejszy do odczytania i zrozumienia, najładniejszy i najkrótszy) sposób:

Powrót z metody, gdy opcjonalny jest pusty?

Szukam ogólnego rozwiązania, które działa dla różnych kombinacji liczb opcji i rozmiarów bloków kodu.

W poniższych przykładach postaram się pokazać, co mam na myśli:

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

To pytanie jest o tym, jak uzyskać dobry aspekt obu powyższych przykładach: typ bezpiecznie opcjonalnego i zwięzłości typów nullable.

Reszta przykładów ilustruje to bardziej.

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

Jak mogę wrócić z metody, jeżeli opcja jest pusta, bez konieczności korzystania get w pozostałej części metody, bez deklarowania dodatkową zmienną i bez dodatkowych poziomów zagnieżdżenia bloku?

Albo, jeśli nie można tego wszystkiego uzyskać, jaki jest najlepszy sposób poradzenia sobie z tą sytuacją?

Answer 1

Można użyć orElse(null):

String o = getOptional().orElse(null); 
if (o == null) { 
    return; 
} 

Answer 2

ifPresent że używasz nie wymaga, aby utworzyć nowy lambda, można po prostu użyć odwołania Metoda:

getOptional().ifPresent(System.out::println); 

ten tak naprawdę nie rozwiązuje przypadku, w którym chcesz warunkować na obecność dwóch opcji. Ale jako alternatywa dla

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

dlaczego nie po prostu odwrócić sytuację, która działa dobrze w przypadku zagnieżdżonych też? Nie ma potrzeby, aby powrót wyraźne:

if (o.isPresent()) { 
    System.out.println(o.get()); 
    if (oo.isPresent()) { 
    System.out.println(oo.get()); 
    } 
} 

Jednak tego rodzaju przypadek użycia sugeruje, że nie jesteś naprawdę korzystają z Opcjonalnie, w przeciwieństwie do wartości pustych. Ogólnie rzecz biorąc, jeśli używasz metody isPresent i get, wówczas opcja Opcjonalnie może nie dostarczyć Ci aż tyle (oprócz tego, że zmusza Cię do rozważenia przypadku, w którym brakuje wartości). Używanie ifPresent, map, filtrów i innych "bardziej funkcjonalnych" metod może być bardziej typowymi zastosowaniami dla wartości Opcjonalnej.

---

Ale w żadnym wypadku nie zwracaj wartości zerowej, gdy obiecujesz opcję opcjonalną. Mimo, że zwracanie wartości null podczas oczekiwania na obiekt jest całkowicie legalne, punktem Opcjonalnym jest właśnie unikanie sprawdzania zerowej wartości.Więc nie rób:

Optional<String> getOptional() { 
    return null; 
} 

ale zamiast zrobić:

Optional<String> getOptional() { 
    return Optional.empty(); 
} 

Inaczej skończyć się zrobić:

Optional<String> o = getOptional(); 
if (o != null && o.isPresent()) { 
    // ... 
} 

który jest tak naprawdę robi to samo coś takiego dwa razy. Użyj opcji opcjonalnej lub użyj wartości zerowej, ale nie rób tego jednocześnie!

Answer 3

Nie sądzę co pytasz jest rzeczywiście możliwe, ale chciałbym zaproponować tylko biorąc cały kod, który działa bezpośrednio na String i zawinąć go w funkcji. Więc funkcja staje się coś takiego:

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

    doThings(o.get()); 
} 

void doThings(String s){ 
    System.out.println(s); 
    //do whatever else with the string. 
} 

ten sposób masz tylko ciąg w zakresie i nie trzeba zadzwonić .get() każdym razem chcesz uzyskać do niego dostęp.

Answer 4

Można użyć ifPresent i map metody zamiast, jeśli funkcja jest nieaktualna i trzeba zrobić skutków ubocznych można użyć ifPresent,

optional.ifPresent(System.out::println); 

Jeśli inny zwrot metoda opiera się na opcjonalnym niż ta metoda może trzeba zwracać Opcjonalnie, jak również i użyć metody mapie

Optional<Integer> getLength(){ 
    Optional<String> hi = Optional.of("hi"); 
    return hi.map(String::length) 
} 

Większość czasu gdy dzwonisz isPresent i get, niewłaściwie używasz Optional.