Класс Optional в Java: что это и зачем он нужен

Приложение падает в продакшене на одной строке:

String summary = book.getChapter(10).getSummary().toUpperCase();

В стектрейсе — NullPointerException, и по нему невозможно понять, что именно вернуло null: книга без десятой главы, глава без краткого содержания или что-то ещё. Сигнатуры методов молчат: getChapter() возвращает Chapter, getSummary() возвращает String — и ни один из типов не сообщает, что результата может не быть. Именно эту проблему и решает класс Optional.

Optional<T> — это класс-контейнер из пакета java.util, который либо содержит одно значение типа T, либо пуст. Он появился в Java 8 и нужен для того, чтобы отсутствие значения было выражено в типе явно, а не спрятано за null. Метод, возвращающий Optional<String>, самим своим объявлением предупреждает: результата может не быть, обработай этот случай.

Проблема: лестница проверок на null

До Java 8 единственным способом сказать «значения нет» был null. Отсюда и классический способ избежать NullPointerException — проверять каждое звено цепочки вызовов:

String summary = "";
if (book != null) {
    Chapter chapter = book.getChapter(10);
    if (chapter != null) {
        if (chapter.getSummary() != null) {
            summary = chapter.getSummary().toUpperCase();
        }
    }
}

Код работает, но у него три беды:

• Шума больше, чем смысла. Полезное действие здесь одно — toUpperCase(). Всё остальное — защитная обвязка.
• Проверки легко забыть. Компилятор не напомнит о пропущенном if. Об этом сообщит NullPointerException у пользователя.
• Неясен контракт. Глядя на Chapter getChapter(int number), нельзя сказать, вернёт ли метод null для несуществующей главы или бросит исключение. Ответ спрятан в документации или в исходниках — но не в типе.

Проверки на null сами по себе не ошибка. Проблема в том, что необходимость этих проверок никак не выражена в коде: она держится на договорённостях и внимательности программиста.

Что такое Optional

java.util.Optional<T> — это обобщённый класс-обёртка над значением, которого может не быть. Объект Optional находится ровно в одном из двух состояний:

• содержит значение — внутри лежит ссылка на объект типа T (всегда не null);
• пуст — значения внутри нет, это и есть аналог «ничего».

Важная деталь устройства класса: у Optional нет публичных конструкторов. Написать new Optional<>("текст") не получится — код не скомпилируется. Экземпляры создаются только статическими фабричными методами Optional.empty(), Optional.of() и Optional.ofNullable(). Такое решение позволяет классу переиспользовать один общий объект для пустого состояния и гарантировать, что внутри непустого Optional никогда не окажется null.

Optional также объявлен как final и неизменяем (immutable): положить в существующий контейнер другое значение нельзя, любая «модификация» порождает новый объект.

Зачем нужен Optional вместо null

Главная ценность Optional не в том, что он сокращает код, а в том, что он переводит отсутствие значения из неявного состояния в явное. Сравните два варианта одного и того же метода:

// Контракт неизвестен: вернёт null? бросит исключение? как повезёт?
Chapter getChapter(int number);

// Контракт очевиден: главы может не быть, и это нормальная ситуация
Optional<Chapter> getChapter(int number);

Во втором случае вызывающий код физически не сможет случайно обратиться к главе напрямую: у Optional<Chapter> нет метода getSummary(). Чтобы добраться до значения, придётся осознанно распаковать контейнер — а значит, подумать о случае, когда он пуст.

В курсовой презентации та же идея показана на уровне поля класса: вместо

class Chapter {
    private String summary;   // может быть null, но по коду этого не видно
}

предлагается писать

class Chapter {
    private Optional<String> summary;   // отсутствие описания заявлено явно
}

Приём наглядно демонстрирует мысль «отсутствие значения должно быть частью типа». На практике, однако, у него есть ограничения — о них в заметке ниже.

Как создать Optional: empty, of, ofNullable

Три фабричных метода покрывают все случаи.

Optional.empty()

Возвращает пустой контейнер — тот самый явный способ сказать «значения нет»:

Optional<String> summary = Optional.empty();
System.out.println(summary);   // Optional.empty

Optional.of(value)

Оборачивает значение, про которое вы точно знаете, что оно не null:

Optional<String> summary = Optional.of("Краткое содержание главы");
System.out.println(summary);   // Optional[Краткое содержание главы]

Если передать null, метод немедленно бросит NullPointerException:

String text = null;
Optional<String> summary = Optional.of(text);   // NullPointerException

Это не недоработка, а защитный механизм: ошибка всплывает в точке создания контейнера, а не через десяток вызовов, где её будет трудно связать с причиной.

Optional.ofNullable(value)

Универсальный вариант: если значение не null — вернётся непустой Optional, если null — пустой. Никаких исключений:

String text = null;
Optional<String> summary = Optional.ofNullable(text);
System.out.println(summary);   // Optional.empty

String another = "Глава 10";
System.out.println(Optional.ofNullable(another));   // Optional[Глава 10]

Именно ofNullable() обычно используют на границе со «старым» кодом и внешними API, которые всё ещё возвращают null.

of или ofNullable: в чём разница

Короткое правило: of() — когда null недопустим и должен сломать выполнение немедленно, ofNullable() — когда null является штатным значением. Оборачивать вызов в Optional.of() «на всякий случай», не будучи уверенным в аргументе, бессмысленно: вы просто перенесёте NullPointerException на строку выше.

Простейший пример использования

Чтобы урок не остался чистой теорией — минимальный цикл «создали контейнер, проверили, забрали значение»:

import java.util.Optional;

public class OptionalDemo {
    public static void main(String[] args) {
        String text = "Краткое содержание главы 10";
        Optional<String> summary = Optional.ofNullable(text);

        if (summary.isPresent()) {
            System.out.println(summary.get().toUpperCase());
        } else {
            System.out.println("Описание отсутствует");
        }

        // то же самое короче, без ручной проверки
        summary.ifPresent(s -> System.out.println(s.length()));
    }
}

Вывод программы:

КРАТКОЕ СОДЕРЖАНИЕ ГЛАВЫ 10
27

Обратите внимание: get() вызывается только после isPresent(). Вызов get() на пустом контейнере бросит NoSuchElementException — по сути ту же аварию, от которой мы уходили, только под другим именем. Поэтому связка isPresent() + get() считается самым примитивным способом работы с Optional: она нужна для понимания устройства класса, но в реальном коде её обычно заменяют более выразительными методами.

Остальные методы — isPresent, get, orElse, orElseGet, filter, map и другие — разобраны в отдельном уроке «Методы Optional».

Что чаще всего понимают неправильно

• «Optional отменяет NullPointerException». Не отменяет. Он делает отсутствие значения видимым в типе, но переменная типа Optional тоже может оказаться null, если кто-то присвоил ей null. Класс помогает дисциплине, а не заменяет её.
• «Нужно переписать весь код на Optional». Не нужно. Массовая замена всех полей и параметров на Optional раздувает код и добавляет объекты на каждый вызов. Начните с возвращаемых значений методов, где результата может не быть: поиск по идентификатору, чтение необязательной настройки, разбор строки.
• «Optional подходит для коллекций». Для пустого списка уже есть пустой список. Optional<List<String>> заставляет вызывающий код различать два одинаковых по смыслу случая — «списка нет» и «список пуст». Возвращайте Collections.emptyList().
• «Optional сравнивают через ==». Это объект, и сравнивать его надо через equals(). Два контейнера равны, если оба пусты либо оба содержат равные значения.

Коротко о главном

• Optional<T> — контейнер из java.util, который либо хранит одно значение типа T, либо пуст. Появился в Java 8.
• Он нужен, чтобы возможное отсутствие результата было видно в сигнатуре метода, а не пряталось за null.
• Публичных конструкторов нет: только Optional.empty(), Optional.of(), Optional.ofNullable().
• of() бросает NullPointerException на null, ofNullable() в этом случае возвращает пустой контейнер.
• Основное применение — возвращаемые значения методов; для полей и параметров есть более простые решения.