Optional w Javie: jak unikać null i NullPointerException

Problem, który rozwiązuje Optional

Metoda, która może nie mieć odpowiedzi, zawsze stawiała w Javie niewygodny wybór: zwrócić null i liczyć na to, że wywołujący pamięta o sprawdzeniu. Zwykle nie pamięta, a skutkiem jest NullPointerException, który pojawia się daleko od metody, która zwróciła null.

Optional<T> to małe pudełko, które albo zawiera wartość, albo jest jawnie puste. Zwracając Optional<User> zamiast User, metoda mówi wywołującym w swojej sygnaturze: "mogę nic nie znaleźć", a kompilator popycha ich do obsłużenia tego przypadku.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> found = Optional.of("Ada");
        Optional<String> missing = Optional.empty();

        System.out.println(found.isPresent());   // true
        System.out.println(missing.isPresent());  // false
    }
}

Tworzenie Optional

Są trzy metody fabrykujące i wybór właściwej ma znaczenie:

• Optional.of(value): wartość nie może być null, w przeciwnym razie od razu rzuca NullPointerException.
• Optional.ofNullable(value): pusty, jeśli wartość to null, w przeciwnym razie z wartością. Używaj go do opakowania czegoś, co może być null.
• Optional.empty(): pusty Optional.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        String maybeNull = System.getenv("DOES_NOT_EXIST");  // zwraca null

        Optional<String> safe = Optional.ofNullable(maybeNull);
        System.out.println(safe.isPresent());  // false, bez wyjątku

        // Optional.of(maybeNull) rzuciłoby tu NullPointerException
        Optional<String> sure = Optional.of("definitely here");
        System.out.println(sure.isPresent());  // true
    }
}

Częsty błąd to sięgnięcie po Optional.of(x) dla wartości, która może być null. To niweczy cały sens i rzuca dokładnie ten wyjątek, którego chcesz uniknąć. W razie wątpliwości użyj ofNullable.

Bezpieczny odczyt wartości

Gdy masz już Optional, celem jest wyciągnięcie wartości bez zakładania, że tam jest. Toporne narzędzie to get() i prawie nigdy nie należy go używać:

Optional<String> name = Optional.empty();
String value = name.get();   // rzuca NoSuchElementException: to tylko przebrany NPE

Zamiast tego podaj wartość zapasową albo zareaguj na obecność wartości. orElse zwraca wartość domyślną, gdy Optional jest pusty; ifPresent uruchamia kod tylko wtedy, gdy wartość istnieje:

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> name = Optional.of("Grace");
        Optional<String> blank = Optional.empty();

        System.out.println(name.orElse("anonymous"));   // Grace
        System.out.println(blank.orElse("anonymous"));  // anonymous

        name.ifPresent(n -> System.out.println("Hello, " + n));
        blank.ifPresent(n -> System.out.println("never prints"));
    }
}

Użyj orElseGet(supplier) zamiast orElse, gdy zbudowanie wartości domyślnej jest kosztowne: supplier uruchamia się tylko wtedy, gdy Optional rzeczywiście jest pusty. Argument orElse jest obliczany zawsze, nawet gdy nie jest potrzebny.

orElseThrow, gdy "to powinno istnieć"

Czasem brak wartości naprawdę jest błędem: wymagana wartość konfiguracji albo użytkownik, który powinien być w bazie danych. orElseThrow zamienia pusty Optional w jasny wyjątek wybranego przez ciebie typu:

import java.util.Optional;

public class Main {
    static Optional<Integer> parsePort(String raw) {
        try {
            return Optional.of(Integer.parseInt(raw));
        } catch (NumberFormatException e) {
            return Optional.empty();
        }
    }

    public static void main(String[] args) {
        int port = parsePort("8080")
            .orElseThrow(() -> new IllegalStateException("port must be a number"));
        System.out.println("listening on " + port);

        try {
            parsePort("nope")
                .orElseThrow(() -> new IllegalStateException("port must be a number"));
        } catch (IllegalStateException e) {
            System.out.println("caught: " + e.getMessage());
        }
    }
}

Czyta się to dużo lepiej niż blok if (opt.isPresent()) i pokazuje błąd wprost w miejscu, w którym występuje.

Przekształcanie przez map i filter

Prawdziwa korzyść to łączenie w łańcuchy. map stosuje funkcję do wartości tylko wtedy, gdy ona istnieje, a pusty Optional zostawia pustym, więc przekształcasz dane, nigdy nie dotykając null. filter odrzuca wartość, jeśli nie przejdzie testu.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> raw = Optional.of("  Coddy  ");

        String result = raw
            .map(String::trim)          // "Coddy"
            .filter(s -> !s.isEmpty())  // zostaw tylko niepuste
            .map(String::toUpperCase)   // "CODDY"
            .orElse("EMPTY");

        System.out.println(result);  // CODDY

        // Pusty Optional przechodzi nietknięty: bez NPE, bez rozgałęzień
        String none = Optional.<String>empty()
            .map(String::trim)
            .orElse("EMPTY");
        System.out.println(none);    // EMPTY
    }
}

Jeśli funkcja mapująca sama zwraca Optional, użyj flatMap zamiast map, żeby uniknąć niezgrabnego Optional<Optional<T>>. To odpowiada rozróżnieniu map/flatMap znanemu ze strumieni: Optional zachowuje się podobnie jak strumień zawierający zero albo jeden element.

Gdzie Optional pasuje (a gdzie nie)

Optional zaprojektowano jako typ zwracany przez metody, które zgodnie z zasadami mogą nie dać wyniku. Klasyczne przykłady to Stream.findFirst(), wyszukiwania w stylu Map i parsowanie. Używaj go tam, a twoje API samo będzie dokumentować swoje luki.

Nie jest przeznaczony do:

• Pól. Nie jest serializowalny i dodaje osobny obiekt na każde pole. Używaj zwykłych referencji i sprawdzaj je w konstruktorze.
• Parametrów metod. Wywołujący musieliby wtedy opakowywać argumenty w Optional.of(...), co jest bardziej uciążliwe niż przeciążenie albo parametr dopuszczający null.
• Kolekcji. Zwracaj pustą List, a nie Optional<List>. Pusta kolekcja już oznacza "nic".

Traktowany jako typ zwracany, Optional zamienia ciche błędy z null w podpowiedzi na etapie kompilacji, by obsłużyć brakujący przypadek.

Dalej: wyjątki

Optional zgrabnie obsługuje codzienny przypadek "wartości może nie być", ale niektóre błędy są naprawdę wyjątkowe: plik, którego nie da się otworzyć, zerwane połączenie sieciowe, dane, których nie da się sparsować. Java modeluje je wyjątkami i o nich jest następna strona.