Зачем использовать Optional в Java 8+ вместо традиционных проверок нулевых указателей?

Недавно мы перешли на Java 8. Теперь я вижу приложения, заполненные Optionalобъектами.

До Java 8 (Стиль 1)

Employee employee = employeeServive.getEmployee();

if(employee!=null){
    System.out.println(employee.getId());
}

После Java 8 (Стиль 2)

Optional<Employee> employeeOptional = Optional.ofNullable(employeeService.getEmployee());
if(employeeOptional.isPresent()){
    Employee employee = employeeOptional.get();
    System.out.println(employee.getId());
}

Я не вижу добавленной стоимости, Optional<Employee> employeeOptional = employeeService.getEmployee();когда сама служба возвращает необязательно:

Исходя из фона Java 6, я вижу Стиль 1 как более понятный и с меньшим количеством строк кода. Есть ли какое-то реальное преимущество, которого мне здесь не хватает?

Консолидирован от понимания всех ответов и дальнейших исследований в блоге

Стиль 2 не подходит для Java 8, чтобы увидеть все преимущества. Вы не хотите if ... useвообще. Смотрите примеры Oracle . Принимая их советы, мы получаем:

Стиль 3

// Changed EmployeeServive to return an optional, no more nulls!
Optional<Employee> employee = employeeServive.getEmployee();
employee.ifPresent(e -> System.out.println(e.getId()));

Или более длинный фрагмент

Optional<Employee> employee = employeeServive.getEmployee();
// Sometimes an Employee has forgotten to write an up-to-date timesheet
Optional<Timesheet> timesheet = employee.flatMap(Employee::askForCurrentTimesheet); 
// We don't want to do the heavyweight action of creating a new estimate if it will just be discarded
client.bill(timesheet.orElseGet(EstimatedTimesheet::new));

Если вы используете Optionalв качестве слоя «совместимости» старый API, который все еще может возвращаться null, может быть полезно создать (не пустой) Optional на последнем этапе, когда вы уверены, что у вас что-то есть. Например, где вы написали:

Optional<Employee> employeeOptional = Optional.ofNullable(employeeService.getEmployee());
if(employeeOptional.isPresent()){
    Employee employeeOptional= employeeOptional.get();
    System.out.println(employee.getId());
}

Я бы выбрал:

Optional.of(employeeService)                 // definitely have the service
        .map(EmployeeService::getEmployee)   // getEmployee() might return null
        .map(Employee::getId)                // get ID from employee if there is one
        .ifPresent(System.out::println);     // and if there is an ID, print it

Дело в том, что вы знаете, что есть служба , отличная от NULL , поэтому вы можете завершить ее Optionalс помощью Optional.of(). Затем, когда вы звоните getEmployee()по этому поводу, вы можете или не можете получить сотрудника. Этот сотрудник может (или, возможно, не может) иметь удостоверение личности. Затем, если у вас есть идентификатор, вы хотите его распечатать.

Там нет необходимости явно проверить любой нуль, наличие и т.д., в этом коде.

Существует почти нет добавленной стоимости в наличии Optionalодного значения. Как вы видели, это просто заменяет проверку на nullпроверку на наличие.

Существует огромное преимущество в том, чтобы иметь Collectionтакие вещи. Все методы потоковой передачи, введенные для замены низкоуровневых циклов старого стиля, понимают Optionalвещи и делают с ними правильные вещи (не обрабатывают их или, в конечном счете, возвращают еще одно незаданное Optional). Если вы имеете дело с n предметами чаще, чем с отдельными предметами (а 99% всех реалистичных программ это делают), то иметь встроенную поддержку для опционально представляемых вещей - огромное преимущество. В идеальном случае вам никогда не придется проверять наличие null или наличие.

Пока вы используете Optionalпросто как модный API для isNotNull(), то да, вы не найдете никаких различий только с проверкой null.

Вещи, которые вы НЕ должны использовать Optionalдля

OptionalBad Code ™ используется только для проверки наличия значения:

// BAD CODE ™ --  just check getEmployee() != null  
Optional<Employee> employeeOptional =  Optional.ofNullable(employeeService.getEmployee());  
if(employeeOptional.isPresent()) {  
    Employee employee = employeeOptional.get();  
    System.out.println(employee.getId());
}  

Вещи, которые вы должны использовать Optionalдля

Избегайте отсутствия значения, создавая его при необходимости при использовании методов API с нулевым возвратом:

Employee employee = Optional.ofNullable(employeeService.getEmployee())
                            .orElseGet(Employee::new);
System.out.println(employee.getId());

Или, если создание нового сотрудника слишком дорого:

Optional<Employee> employee = Optional.ofNullable(employeeService.getEmployee());
System.out.println(employee.map(Employee::getId).orElse("No employee found"));

Кроме того, чтобы все знали, что ваши методы могут не возвращать значение (если по какой-либо причине вы не можете вернуть значение по умолчанию, как описано выше):

// Your code without Optional
public Employee getEmployee() {
    return someCondition ? null : someEmployee;
}
// Someone else's code
Employee employee = getEmployee(); // compiler doesn't complain
// employee.get...() -> NPE awaiting to happen, devs criticizing your code

// Your code with Optional
public Optional<Employee> getEmployee() {
    return someCondition ? Optional.empty() : Optional.of(someEmployee);
}
// Someone else's code
Employee employee = getEmployee(); // compiler complains about incompatible types
// Now devs either declare Optional<Employee>, or just do employee = getEmployee().get(), but do so consciously -- not your fault.

И, наконец, есть все потоковые методы, которые уже были объяснены в других ответах, хотя на самом деле вы решили не использовать их, Optionalа использовать Optionalпредоставленные кем-то другим.

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

//service 1
Optional<Employee> employeeOptional = employeeService.getEmployee();
if(employeeOptional.isPresent()){
    Employee employeeOptional= employeeOptional.get();
    System.out.println(employee.getId());
}

//service 2
Employee employee = employeeService.getEmployeeXTPO();
System.out.println(employee.getId());

Ваша главная ошибка в том, что вы все еще мыслите более процедурно. Это не критика вас как личности, это просто наблюдение. Мышление в более функциональных терминах приходит со временем и практикой, и поэтому методы isPresent и выглядят как наиболее очевидные правильные вещи для вас. Ваша второстепенная незначительная ошибка - создание вашего Optional внутри вашего метода. Необязательный предназначен для того, чтобы помочь документировать, что что-то может или не может возвращать значение. Вы можете ничего не получить.

Это привело к тому, что вы пишете совершенно разборчивый код, который кажется вполне разумным, но вас соблазнили мерзкие двойники-соблазнители, которые получают и представляют.

Конечно, быстро возникает вопрос: «Почему они присутствуют и даже там?»

Многие люди здесь упускают из виду то, что isPresent () состоит в том, что это не то, что сделано для нового кода, написанного полностью занятыми людьми с тем, насколько чертовски полезны лямбды и кому нравится функциональность.

Это, однако, дает нам несколько (два) хороших, великих, гламурных (?) Преимуществ:

• Это облегчает переход унаследованного кода на использование новых функций.
• Это облегчает изучение кривых Факультативного.

Первый довольно прост.

Представьте, что у вас есть API, который выглядел так:

public interface SnickersCounter {
  /** 
   * Provides a proper count of how many snickers have been consumed in total.
   */
  public SnickersCount howManySnickersHaveBeenEaten();

  /**
    * returns the last snickers eaten.<br>
    * If no snickers have been eaten null is returned for contrived reasons.
    */
  public Snickers lastConsumedSnickers();
}

И у вас был унаследованный класс, использующий это как таковой (заполните пробелы):

Snickers lastSnickers = snickersCounter.lastConsumedSnickers();
if(null == lastSnickers) {
  throw new NoSuchSnickersException();
}
else {
  consumer.giveDiabetes(lastSnickers);
}

Придуманный пример, чтобы быть уверенным. Но потерпите меня здесь.

Java 8 уже запущена, и мы карабкаемся, чтобы попасть на борт. Таким образом, мы хотим заменить наш старый интерфейс чем-то, что возвращает Optional. Почему? Потому что, как кто-то другой уже любезно упомянул: это снимает догадки о том, может ли что-то быть нулевым. Это уже было указано другими. Но сейчас у нас проблема. Представьте, что у нас есть (извините, когда я нажимаю alt + F7 невинного метода) 46 мест, где этот метод вызывается в хорошо проверенном унаследованном коде, который отлично работает в противном случае. Теперь вы должны обновить все это.

Это где настоящее сияет.

Потому что сейчас: Snickers lastSnickers = snickersCounter.lastConsumedSnickers (); if (null == lastSnickers) {throw new NoSuchSnickersException (); } else {consumer.giveDiabetes (lastSnickers); }

будет выглядеть так:

Optional<Snickers> lastSnickers = snickersCounter.lastConsumedSnickers();
if(!lastSnickers.isPresent()) {
  throw new NoSuchSnickersException();
}
else {
  consumer.giveDiabetes(lastSnickers.get());
}

И это простое изменение, которое вы можете дать новому юниору: он может сделать что-то полезное, и он сможет одновременно исследовать кодовую базу. беспроигрышная. В конце концов, что-то похожее на этот шаблон довольно широко распространено. И теперь вам не нужно переписывать код, чтобы использовать лямбды или что-то еще. (В этом конкретном случае это было бы тривиально, но я оставляю продуманные примеры, где это было бы сложно в качестве упражнения для читателя.)

Обратите внимание, что это означает, что то, как вы это сделали, по сути является способом работы с устаревшим кодом без дорогостоящих переписываний. Так что насчет нового кода?

Ну, в вашем случае, когда вы просто хотите что-то напечатать, вы просто сделаете:

. SnickersCounter.lastConsumedSnickers () ifPresent (System.out :: Println);

Что довольно просто и совершенно понятно. Точка, которая медленно поднимается к поверхности, состоит в том, что существуют варианты использования для get () и isPresent (). Они предназначены для того, чтобы позволить вам механически модифицировать существующий код, чтобы использовать новые типы, не слишком задумываясь об этом. То, что вы делаете, поэтому вводится в заблуждение следующими способами:

• Вы вызываете метод, который может вернуть ноль. Правильная идея состоит в том, что метод возвращает ноль.
• Вы используете устаревшие методы bandaid, чтобы справиться с этим необязательным, вместо того, чтобы использовать новые вкусные методы, которые содержат причудливость лямбды.

Если вы хотите использовать Optional в качестве простой проверки нулевой безопасности, вам нужно просто выполнить следующее:

new Optional.ofNullable(employeeServive.getEmployee())
    .map(Employee::getId)
    .ifPresent(System.out::println);

Конечно, красивая версия выглядит так:

employeeService.getEmployee()
    .map(Employee::getId)
    .ifPresent(System.out::println);

Кстати, хотя это ни в коем случае не требуется, я рекомендую использовать новую строку для каждой операции, чтобы ее было легче читать. Легко читать и понимать бьет краткость в любой день недели.

Это, конечно, очень простой пример, в котором легко понять все, что мы пытаемся сделать. Это не всегда так просто в реальной жизни. Но обратите внимание, что в этом примере мы выражаем наши намерения. Мы хотим ПОЛУЧИТЬ сотрудника, ПОЛУЧИТЬ его удостоверение личности и, если возможно, распечатать его. Это вторая большая победа с Факультативным. Это позволяет нам создавать более понятный код. Я также думаю, что создание таких вещей, как создание метода, который делает кучу вещей, чтобы вы могли передать их на карту, в общем, хорошая идея.

Я не вижу преимущества в стиле 2. Вы все еще должны понимать, что вам нужна нулевая проверка, и теперь она еще больше, а значит, менее читабельна.

Лучший стиль был бы, если employeeServive.getEmployee () вернул бы Optional, и тогда код стал бы:

Optional<Employee> employeeOptional = employeeServive.getEmployee();
if(employeeOptional.isPresent()){
    Employee employee= employeeOptional.get();
    System.out.println(employee.getId());
}

Таким образом, вы не можете вызвать callemployeeServive.getEmployee (). GetId (), и вы заметили, что вам следует каким-то образом обрабатывать необязательные значения. И если во всей вашей кодовой базе методы никогда не вернут null (или почти никогда с хорошо известными вашей команде исключениями из этого правила), это повысит безопасность от NPE.

Я думаю, что наибольшим преимуществом является то, что если сигнатура вашего метода возвращает, Employeeвы не проверяете на ноль. По этой подписи вы знаете, что гарантированно вернуть работника. Вам не нужно обрабатывать случай отказа. С опциональной вы знаете, что вы делаете.

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

Однако, чтобы это работало, вы должны последовательно применять этот шаблон.

Мой ответ: просто не надо. По крайней мере, дважды подумайте, действительно ли это улучшение.

Выражение (взято из другого ответа) как

Optional.of(employeeService)                 // definitely have the service
        .map(EmployeeService::getEmployee)   // getEmployee() might return null
        .map(Employee::getId)                // get ID from employee if there is one
        .ifPresent(System.out::println);     // and if there is an ID, print it

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

Это выглядит лучше, чем в старом стиле

Employee employee = employeeService.getEmployee();
if (employee != null) {
    ID id = employee.getId();
    if (id != null) {
        System.out.println(id);
    }
}

что делает очевидным, что могут быть elseоговорки.

Функциональный стиль

• выглядит совершенно иначе (и нечитаемо для людей, не привыкших к нему)
• это боль отлаживать
• не может быть легко расширен для обработки «отсутствующего» случая ( orElseне всегда достаточно)
• вводит в заблуждение игнорированием «отсутствующего» дела

Ни в коем случае его не следует использовать как панацею. Если это было универсально применимо, то семантика .оператора должна быть заменена семантикой ?.оператора , NPE забыт и все проблемы проигнорированы.

Будучи большим поклонником Java, я должен сказать, что функциональный стиль - просто замена плохого человека на Java.

employeeService
.getEmployee()
?.getId()
?.apply(id => System.out.println(id));

хорошо известен из других языков. Согласны ли мы с этим утверждением?

• не является (действительно) функциональным?
• очень похоже на код старого стиля, просто намного проще?
• гораздо удобнее для чтения, чем функциональный стиль?
• подходит для отладчика?

Необязательным является понятие (тип более высокого порядка), исходящее из функционального программирования. Использование этого избавляет от вложенной проверки нуля и спасает вас от пирамиды гибели.