¿Por qué usar Opcional en Java 8+ en lugar de las comprobaciones de puntero nulo tradicionales?

Recientemente nos hemos mudado a Java 8. Ahora, veo aplicaciones inundadas de Optionalobjetos.

Antes de Java 8 (Estilo 1)

Employee employee = employeeServive.getEmployee();

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

Después de Java 8 (Estilo 2)

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

No veo ningún valor agregado de Optional<Employee> employeeOptional = employeeService.getEmployee();cuando el servicio en sí mismo devuelve opcional:

Viniendo de un fondo de Java 6, veo el Estilo 1 como más claro y con menos líneas de código. ¿Hay alguna ventaja real que me falta aquí?

Consolidado de la comprensión de todas las respuestas y más investigación en el blog

Style 2 no va a Java 8 lo suficiente como para ver el beneficio completo. No quieres el if ... useen absoluto. Ver los ejemplos de Oracle . Siguiendo sus consejos, obtenemos:

Estilo 3

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

O un fragmento más largo

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

Si está utilizando Optionalcomo una capa de "compatibilidad" entre una API anterior que aún puede regresar null, puede ser útil crear el Opcional (no vacío) en la última etapa de que está seguro de que tiene algo. Por ejemplo, donde escribiste:

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

Yo optaría por:

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

El punto es que usted sabe que hay un no nulo empleado del servicio , por lo que puede envolver que hasta en un Optionalcon Optional.of(). Luego, cuando recurras getEmployee()a eso, puedes o no conseguir un empleado. Ese empleado puede (o posiblemente no tener) una identificación. Luego, si terminó con una identificación, desea imprimirla.

No hay necesidad de verificar explícitamente cualquier nulo, presencia, etc., en este código.

Casi no hay valor agregado al tener un Optionalvalor único. Como has visto, eso simplemente reemplaza un cheque por nullun cheque de presencia.

Hay un gran valor agregado en tener una Collectionde esas cosas. Todos los métodos de transmisión introducidos para reemplazar los bucles de bajo nivel de estilo antiguo entienden las Optionalcosas y hacen lo correcto al respecto (no las procesan o finalmente devuelven otro desarmado Optional). Si maneja n elementos con más frecuencia que con elementos individuales (y el 99% de todos los programas realistas lo hacen), entonces es una gran mejora tener soporte incorporado para las cosas opcionalmente presentes. En el caso ideal, nunca tiene que verificar null ni presencia.

Siempre y cuando use Optionalcomo una API elegante isNotNull(), entonces sí, no encontrará ninguna diferencia con solo verificar null.

Cosas que NO debes usar Optionalpara

Usar Optionalsolo para verificar la presencia de un valor es Bad 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());
}  

Cosas que deberías usar Optionalpara

Evite que un valor no esté presente, produciendo uno cuando sea necesario cuando utilice métodos API de retorno nulo:

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

O, si crear un nuevo empleado es demasiado costoso:

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

Además, hacer que todos sepan que sus métodos podrían no devolver un valor (si, por alguna razón, no puede devolver un valor predeterminado como el anterior):

// 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.

Y, por último, están todos los métodos de flujo que ya se han explicado en otras respuestas, aunque esos no son realmente los que usted decide usar, Optionalsino que utiliza los Optionalproporcionados por otra persona.

El punto clave para mí al usar Opcional es mantenerse claro cuando el desarrollador necesita verificar si el valor de retorno de la función o no.

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

Su principal error es que todavía está pensando en términos más procesales. Esto no pretende ser una crítica de ti como persona, es simplemente una observación. Pensar en términos más funcionales viene con tiempo y práctica, y por lo tanto, los métodos están presentes y se ven como las cosas correctas más obvias para usted. Su error secundario secundario es crear su Opcional dentro de su método. El Opcional está destinado a ayudar a documentar que algo puede o no devolver un valor. Puede que no consigas nada.

Esto te ha llevado a escribir un código perfectamente legible que parece perfectamente razonable, pero te sedujeron las viles tentadoras gemelas que se ponen y están presentes.

Por supuesto, la pregunta se convierte rápidamente en "¿por qué está presente y llega hasta allí?"

Una cosa que mucha gente extraña aquí es que Presente () es que no es algo creado para un nuevo código escrito por personas totalmente conscientes de cuán malditas son las lambdas útiles y a las que les gusta lo funcional.

Sin embargo, nos da algunos (dos) beneficios buenos, geniales y glamorosos (?):

• Facilita la transición del código heredado para usar las nuevas funciones.
• Facilita las curvas de aprendizaje de Opcional.

El primero es bastante simple.

Imagine que tiene una API que se ve así:

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

Y tenía una clase heredada usando esto como tal (complete los espacios en blanco):

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

Un ejemplo artificial para estar seguro. Pero ten paciencia conmigo aquí.

Java 8 se ha lanzado ahora y estamos luchando por subir a bordo. Entonces, una de las cosas que hacemos es que queremos reemplazar nuestra interfaz anterior con algo que devuelva Opcional. ¿Por qué? Porque como alguien más ya ha mencionado amablemente: esto elimina las conjeturas de si algo puede ser nulo o no. Esto ya ha sido señalado por otros. Pero ahora tenemos un problema. Imagine que tenemos (disculpe mientras presiono alt + F7 en un método inocente), 46 lugares donde se llama a este método en código heredado bien probado que de lo contrario hace un excelente trabajo. Ahora tienes que actualizar todo esto.

ESTO es donde brilla IsPresent.

Porque ahora: Snickers lastSnickers = snickersCounter.lastConsumedSnickers (); if (null == lastSnickers) {lanzar una nueva NoSuchSnickersException (); } else {consumer.giveDiabetes (lastSnickers); }

se convierte en:

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

Y este es un cambio simple que puede darle al nuevo junior: puede hacer algo útil y podrá explorar la base de código al mismo tiempo. ganar-ganar Después de todo, algo similar a este patrón está bastante extendido. Y ahora no tiene que volver a escribir el código para usar lambdas ni nada. (En este caso particular, sería trivial, pero dejo pensar ejemplos en los que sería difícil como ejercicio para el lector).

Tenga en cuenta que esto significa que la forma en que lo hizo es esencialmente una forma de lidiar con el código heredado sin hacer reescrituras costosas. Entonces, ¿qué pasa con el nuevo código?

Bueno, en su caso, donde solo desea imprimir algo, simplemente haría:

snickersCounter.lastConsumedSnickers (). ifPresent (System.out :: println);

Lo cual es bastante simple y perfectamente claro. El punto que burbujea lentamente hacia la superficie es que existen casos de uso para get () y isPresent (). Están ahí para permitirle modificar mecánicamente el código existente para usar los tipos más nuevos sin pensar demasiado en ello. Por lo tanto, lo que está haciendo está mal orientado de las siguientes maneras:

• Está llamando a un método que puede devolver nulo. La idea correcta sería que el método devuelve nulo.
• Estás utilizando los métodos de bandaid heredados para lidiar con esta opción, en lugar de utilizar los nuevos métodos sabrosos que contienen fantasía de lambda.

Si desea utilizar Opcional como una simple verificación de seguridad nula, lo que debería haber hecho es simplemente esto:

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

Por supuesto, la buena versión de esto se ve así:

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

Por cierto, aunque de ninguna manera es obligatorio, recomiendo usar una nueva línea por operación, para que sea más fácil de leer. Fácil de leer y comprender mejor que la concisión cualquier día de la semana.

Por supuesto, este es un ejemplo muy simple en el que es fácil entender todo lo que estamos tratando de hacer. No siempre es así de simple en la vida real. Pero observe cómo en este ejemplo, lo que estamos expresando son nuestras intenciones. Queremos OBTENER el empleado, OBTENER su identificación y, si es posible, imprimirlo. Esta es la segunda gran victoria con Opcional. Nos permite crear un código más claro. También creo que hacer cosas como hacer un método que haga un montón de cosas para que puedas alimentarlo a un mapa es, en general, una buena idea.

No veo beneficio en el Estilo 2. Todavía debe darse cuenta de que necesita la verificación nula y ahora es aún más grande, por lo tanto, menos legible.

Sería un mejor estilo, si employeeServive.getEmployee () devolvería Opcional y luego el código sería:

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

De esta manera no puede llamar empleeeServive.getEmployee (). GetId () y observa que debe manejar el valor opcional de alguna manera. Y si en todos sus métodos de base de código nunca devuelve nulo (o casi nunca con excepciones bien conocidas por su equipo a esta regla), aumentará la seguridad contra NPE.

Creo que el mayor beneficio es que si su firma del método devuelve una Employeeque no comprobar NULL. Usted sabe con esa firma que se garantiza que devolverá a un empleado. No necesita manejar un caso de falla. Con un opcional sabes que lo haces.

En el código que he visto, hay cheques nulos que nunca fallarán, ya que las personas no quieren rastrear el código para determinar si es posible un nulo, por lo que arrojan cheques nulos en todas partes a la defensiva. Esto hace que el código sea un poco más lento, pero lo más importante es que hace que el código sea mucho más ruidoso.

Sin embargo, para que esto funcione, debe aplicar este patrón de manera consistente.

Mi respuesta es: simplemente no. Al menos piénsalo dos veces si es realmente una mejora

Una expresión (tomada de otra respuesta) como

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

parece ser la forma funcional correcta de tratar con los métodos de retorno originalmente anulables. Se ve bien, nunca arroja y nunca te hace pensar en manejar el caso "ausente".

Se ve mejor que la forma antigua

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

lo que hace obvio que puede haber elsecláusulas.

El estilo funcional

• se ve completamente diferente (y es ilegible para las personas que no están acostumbradas)
• es un dolor de depurar
• no se puede extender fácilmente para manejar el caso "ausente" ( orElseno siempre es suficiente)
• induce a error a ignorar el caso "ausente"

En ningún caso debe usarse como panacea. Si fuera universalmente aplicable, entonces la semántica del .operador debería ser reemplazada por la semántica del ?.operador , el NPE olvidado y todos los problemas ignorados.

Si bien soy un gran fanático de Java, debo decir que el estilo funcional es solo el sustituto de la declaración de un pobre hombre de Java

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

bien conocido de otros idiomas. ¿Estamos de acuerdo en que esta declaración

• no es (realmente) funcional?
• es muy similar al código antiguo, pero mucho más simple?
• ¿Es mucho más legible que el estilo funcional?
• es amigable para el depurador?

Opcional es un concepto (un tipo de orden superior) que proviene de la programación funcional. Usarlo elimina la comprobación nula anidada y te salva de la pirámide de la fatalidad.