Java Optional: как избежать null и NullPointerException

Какую проблему решает Optional

У метода, у которого может не быть ответа, в Java всегда был неудобный выбор: вернуть null и надеяться, что вызывающий код не забудет проверить. Обычно он забывает, и в результате возникает NullPointerException, которое всплывает далеко от метода, вернувшего null.

Optional<T> — это маленькая коробка, которая либо содержит значение, либо явно пуста. Возвращая Optional<User> вместо User, метод прямо в своей сигнатуре говорит вызывающему коду «здесь может ничего не найтись» — и компилятор направляет его к обработке этого случая.

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

Создание Optional

Есть три фабричных метода, и выбор правильного имеет значение:

• Optional.of(value) — значение должно быть не-null, иначе он тут же бросает NullPointerException.
• Optional.ofNullable(value) — пустой, если значение null, и заполненный в противном случае. Используй его, чтобы обернуть то, что может быть null.
• Optional.empty() — пустой optional.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        String maybeNull = System.getenv("DOES_NOT_EXIST");  // возвращает null

        Optional<String> safe = Optional.ofNullable(maybeNull);
        System.out.println(safe.isPresent());  // false, без исключения

        // Optional.of(maybeNull) бросил бы NullPointerException здесь
        Optional<String> sure = Optional.of("definitely here");
        System.out.println(sure.isPresent());  // true
    }
}

Частая ошибка — хвататься за Optional.of(x) для значения, которое может быть null: это сводит на нет всю идею и бросает именно то исключение, которого ты пытался избежать. Если сомневаешься — используй ofNullable.

Безопасное чтение значения

Когда у тебя есть optional, цель — извлечь значение, не предполагая, что оно там есть. Грубый инструмент — это get(), и его почти никогда не стоит использовать:

Optional<String> name = Optional.empty();
String value = name.get();   // бросает NoSuchElementException — замаскированное NPE

Вместо этого задай запасное значение или отреагируй на наличие. orElse возвращает значение по умолчанию, когда пусто; ifPresent выполняет код только тогда, когда значение есть:

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

Используй orElseGet(supplier) вместо orElse, когда значение по умолчанию дорого создавать: supplier выполняется, только если optional действительно пуст. Аргумент orElse вычисляется всегда, даже когда он не нужен.

orElseThrow для «это должно существовать»

Иногда пустота — это и правда ошибка: обязательное значение конфигурации, пользователь, который должен быть в базе данных. orElseThrow превращает пустой optional в понятное исключение на твой выбор:

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

Это читается гораздо лучше блока if (opt.isPresent()) и делает сбой явным прямо в том месте, где он происходит.

Преобразование с помощью map и filter

Настоящая выгода — в цепочках вызовов. map применяет функцию к значению только если оно присутствует и оставляет пустой optional пустым — так что ты преобразуешь, ни разу не касаясь null. filter отбрасывает значение, если оно не проходит проверку.

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())  // оставить только непустое
            .map(String::toUpperCase)   // "CODDY"
            .orElse("EMPTY");

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

        // Пустой optional проходит насквозь нетронутым — ни NPE, ни ветвлений
        String none = Optional.<String>empty()
            .map(String::trim)
            .orElse("EMPTY");
        System.out.println(none);    // EMPTY
    }
}

Если твоя функция отображения сама возвращает Optional, используй flatMap вместо map, чтобы избежать неудобного Optional<Optional<T>>. Это отражает различие между map/flatMap, которое ты видел у стримов: Optional ведёт себя во многом как стрим из нуля или одного элемента.

Где место Optional (а где нет)

Optional задуман как тип возвращаемого значения для методов, которые законно могут не дать результата: канонические примеры — Stream.findFirst(), поиски в стиле Map и разбор. Используй его там, и твой API сам задокументирует свои пробелы.

Он не предназначен для:

• Полей. Он не сериализуем и добавляет по объекту на каждое поле. Используй обычные ссылки и проверяй в конструкторе.
• Параметров метода. Тогда вызывающему коду придётся оборачивать аргументы в Optional.of(...), что шумнее, чем перегрузка или параметр, допускающий null.
• Коллекций. Возвращай пустой List, а не Optional<List>. Пустая коллекция уже означает «ничего».

Используемый как тип возвращаемого значения, Optional превращает тихие null-баги в подсказки на этапе компиляции обработать отсутствующий случай.

Далее: Исключения

Optional чисто обрабатывает повседневный случай «значения может и не быть», но некоторые сбои действительно исключительны: файл, который не открывается, оборвавшаяся сеть, ввод, который невозможно разобрать. Java моделирует их с помощью исключений — об этом и следующая страница.