¿Estilo funcional de Optional.ifPresent y if-not-Present de Java 8?

Si encuentras algo que te causa duda nos puedes dejar un comentario y haremos todo lo posible de ayudarte lo más rápido posible.

Solución:

Si está usando Java 9+, puede usar ifPresentOrElse() método:

opt.ifPresentOrElse(
   value -> System.out.println("Found: " + value),
   () -> System.out.println("Not found")
);

Para mí, la respuesta de @Dane White está bien, primero no me gustó usar Runnable pero no pude encontrar ninguna alternativa.

Aquí otra implementación que preferí más:

public class OptionalConsumer 
    private Optional optional;

    private OptionalConsumer(Optional optional) 
        this.optional = optional;
    

    public static  OptionalConsumer of(Optional optional) 
        return new OptionalConsumer<>(optional);
    

    public OptionalConsumer ifPresent(Consumer c) 
        optional.ifPresent(c);
        return this;
    

    public OptionalConsumer ifNotPresent(Runnable r) 
        if (!optional.isPresent()) 
            r.run();
        
        return this;
    

Entonces:

Optional o = Optional.of(...);
OptionalConsumer.of(o).ifPresent(s -> System.out.println("isPresent " + s))
                .ifNotPresent(() -> System.out.println("! isPresent"));

Actualización 1:

la solución anterior para la forma tradicional de desarrollo cuando tiene el valor y desea procesarlo, pero ¿qué pasa si quiero definir la funcionalidad y la ejecución será entonces? Verifique la mejora a continuación;

public class OptionalConsumer implements Consumer> {
private final Consumer c;
private final Runnable r;

public OptionalConsumer(Consumer c, Runnable r) 
    super();
    this.c = c;
    this.r = r;


public static  OptionalConsumer of(Consumer c, Runnable r) 
    return new OptionalConsumer(c, r);


@Override
public void accept(Optional t) 
    if (t.isPresent()) 
        c.accept(t.get());
    
    else 
        r.run();
    

Entonces podría usarse como:

Consumer> c = OptionalConsumer.of(
    System.out::println, 
    () -> System.out.println("Not fit")
);

IntStream.range(0, 100)
    .boxed()
    .map(i -> Optional.of(i)
    .filter(j -> j % 2 == 0))
    .forEach(c);

En este nuevo código tienes 3 cosas:

1. puede definir la funcionalidad antes de la existente de un objeto fácil.
2. al no crear una referencia de objeto para cada Opcional, solo uno, tiene menos memoria que menos GC.
3. está implementando el consumidor para un mejor uso con otros componentes.

Por cierto, ahora su nombre es más descriptivo, en realidad es Consumer>

Java 9 presenta

ifPresentOrElse si un valor está presente, realiza la acción dada con el valor; de lo contrario, realiza la acción dada basada en vacío.

Consulte la excelente hoja de trucos Opcional en Java 8.

Proporciona todas las respuestas para la mayoría de los casos de uso.

Breve resumen a continuación

ifPresent() – hacer algo cuando se establece Opcional

opt.ifPresent(x -> print(x)); 
opt.ifPresent(this::print);

filter() – rechazar (filtrar) ciertos valores opcionales.

opt.filter(x -> x.contains("ab")).ifPresent(this::print);

map() – transforma el valor si está presente

opt.map(String::trim).filter(t -> t.length() > 1).ifPresent(this::print);

orElse()/orElseGet() – se vuelve vacío Opcional a la T predeterminada

int len = opt.map(String::length).orElse(-1);
int len = opt.
    map(String::length).
    orElseGet(() -> slowDefault());     //orElseGet(this::slowDefault)

orElseThrow() – lanza excepciones perezosamente en espacios vacíos Opcional

opt.
filter(s -> !s.isEmpty()).
map(s -> s.charAt(0)).
orElseThrow(IllegalArgumentException::new);

Si estás contento con lo expuesto, puedes dejar un ensayo acerca de qué le añadirías a este artículo.

---

---

Utiliza Nuestro Buscador