usage - Java 8 opcional: ifPresent return object oElseThrow excepción

optional null java 8

Question

Estoy tratando de hacer algo como esto:

 private String getStringIfObjectIsPresent(Optional<Object> object){
        object.ifPresent(() ->{
            String result = "result";
            //some logic with result and return it
            return result;
        }).orElseThrow(MyCustomException::new);
    }

Esto no funcionará, porque ifPresent toma la interfaz funcional del consumidor como parámetro, que tiene una aceptación nula (T t). No puede devolver ningún valor. Hay alguna otra forma de hacerlo ?

Answer 1

Dos opciones aquí:

Reemplace ifPresent con map y use Function lugar de Consumer

private String getStringIfObjectIsPresent(Optional<Object> object) {
    return object
            .map(obj -> {
                String result = "result";
                //some logic with result and return it
                return result;
            })
            .orElseThrow(MyCustomException::new);
}

Use isPresent :

private String getStringIfObjectIsPresent(Optional<Object> object) {
    if (object.isPresent()) {
        String result = "result";
        //some logic with result and return it
        return result;
    } else {
        throw new MyCustomException();
    }
}

Answer 2

En realidad lo que estás buscando es: Optional.map . Tu código se vería así:

object.map(o -> "result" /* or your function */)
      .orElseThrow(MyCustomException::new);

Prefiero omitir pasar el Optional si puedes. Al final no ganas nada usando un Optional aquí. Una variante ligeramente más:

public String getString(Object yourObject) {
  if (Objects.isNull(yourObject)) { // or use requireNonNull instead if NullPointerException suffices
     throw new MyCustomException();
  }
  String result = ...
  // your string mapping function
  return result;
}

Si ya tiene el objeto Optional debido a otra llamada, le recomendaría que utilice el método map , en lugar de isPresent , etc. por la única razón, que lo encuentro más legible (claramente una decisión subjetiva ;-) ).

Answer 3

Prefiero mapear después de asegurarme de que el valor esté disponible

private String getStringIfObjectIsPresent(Optional<Object> object) {
   Object ob = object.orElseThrow(MyCustomException::new);
    // do your mapping with ob
   String result = your-map-function(ob);
  return result;
}

o un trazador de líneas

private String getStringIfObjectIsPresent(Optional<Object> object) {
   return your-map-function(object.orElseThrow(MyCustomException::new));
}

Answer 4

Utilice la función de map su lugar. Transforma el valor dentro de lo opcional.

Me gusta esto:

private String getStringIfObjectIsPresent(Optional<Object> object) {
    return object.map(() -> {
        String result = "result";
        //some logic with result and return it
        return result;
    }).orElseThrow(MyCustomException::new);
}