Estilo funcional do Optional.ifPresent e se não estiver presente do Java 8?

No Java 8, quero fazer algo com um Optionalobjeto, se estiver presente, e fazer outra coisa, se não estiver presente.

if (opt.isPresent()) {
  System.out.println("found");
} else {
  System.out.println("Not found");
}

Este não é um 'estilo funcional', no entanto.

Optionaltem um ifPresent()método, mas não consigo encadear um orElse()método.

Assim, não posso escrever:

opt.ifPresent( x -> System.out.println("found " + x))
   .orElse( System.out.println("NOT FOUND"));

Em resposta a @assylias, acho que não Optional.map()funciona para o seguinte caso:

opt.map( o -> {
  System.out.println("while opt is present...");
  o.setProperty(xxx);
  dao.update(o);
  return null;
}).orElseGet( () -> {
  System.out.println("create new obj");
  dao.save(new obj);
  return null;
});

Nesse caso, quando optpresente, atualizo sua propriedade e salvo no banco de dados. Quando não está disponível, eu crio um novo obje salvo no banco de dados.

Nota nas duas lambdas eu tenho que voltar null.

Mas quando optestiver presente, as duas lambdas serão executadas. objserá atualizado e um novo objeto será salvo no banco de dados. Isso ocorre por causa do return nullprimeiro lambda. E orElseGet()continuará a executar.

Para mim, a resposta de @Dane White é boa, primeiro não gostei de usar o Runnable, mas não encontrei alternativas, aqui outra implementação preferi mais

public class OptionalConsumer<T> {
    private Optional<T> optional;

    private OptionalConsumer(Optional<T> optional) {
        this.optional = optional;
    }

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

    public OptionalConsumer<T> ifPresent(Consumer<T> c) {
        optional.ifPresent(c);
        return this;
    }

    public OptionalConsumer<T> ifNotPresent(Runnable r) {
        if (!optional.isPresent()) {
            r.run();
        }
        return this;
    }
}

Então :

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

Atualização 1:

a solução acima para a maneira tradicional de desenvolvimento quando você tem o valor e deseja processá-lo, mas e se eu quiser definir a funcionalidade e a execução será então, verifique abaixo o aprimoramento;

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

public OptionalConsumer(Consumer<T> c, Runnable r) {
    super();
    this.c = c;
    this.r = r;
}

public static <T> OptionalConsumer<T> of(Consumer<T> c, Runnable r) {
    return new OptionalConsumer(c, r);
}

@Override
public void accept(Optional<T> t) {
    if (t.isPresent()) {
        c.accept(t.get());
    }
    else {
        r.run();
    }
}

Então poderia ser usado como:

    Consumer<Optional<Integer>> 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);

Neste novo código, você tem três coisas:

1. pode definir a funcionalidade antes da existência do objeto easy.
2. não criando referência de objeto para cada opcional, apenas um, você tem menos memória e menos GC.
3. está implementando consumidor para melhor uso com outros componentes.

a propósito, agora seu nome é mais descritivo, na verdade é Consumidor>

Se você estiver usando Java 9+, poderá usar o ifPresentOrElse()método:

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

O Java 9 apresenta

ifPresentOrElse se um valor estiver presente, executa a ação especificada com o valor, caso contrário, executa a ação baseada em vazio especificada.

Veja excelente Opcional na cábula Java 8 .

Ele fornece todas as respostas para a maioria dos casos de uso.

Breve resumo abaixo

ifPresent () - faça algo quando Opcional estiver definido

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

filter () - rejeita (filtra) determinados valores opcionais.

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

map () - transforma valor se presente

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

orElse () / orElseGet () - ficando vazio Opcional para o padrão T

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

orElseThrow () - lança preguiçosamente exceções em vazio

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

Uma alternativa é:

System.out.println(opt.map(o -> "Found")
                      .orElse("Not found"));

Eu não acho que melhora a legibilidade, no entanto.

Ou, como Marko sugeriu, use um operador ternário:

System.out.println(opt.isPresent() ? "Found" : "Not found");

Outra solução seria usar funções de ordem superior da seguinte maneira

opt.<Runnable>map(value -> () -> System.out.println("Found " + value))
   .orElse(() -> System.out.println("Not Found"))
   .run();

Não há uma ótima maneira de fazer isso imediatamente. Se você quiser usar a sintaxe do limpador regularmente, poderá criar uma classe de utilitário para ajudar:

public class OptionalEx {
    private boolean isPresent;

    private OptionalEx(boolean isPresent) {
        this.isPresent = isPresent;
    }

    public void orElse(Runnable runner) {
        if (!isPresent) {
            runner.run();
        }
    }

    public static <T> OptionalEx ifPresent(Optional<T> opt, Consumer<? super T> consumer) {
        if (opt.isPresent()) {
            consumer.accept(opt.get());
            return new OptionalEx(true);
        }
        return new OptionalEx(false);
    }
}

Em seguida, você pode usar uma importação estática em outro lugar para obter a sintaxe mais próxima do que deseja:

import static com.example.OptionalEx.ifPresent;

ifPresent(opt, x -> System.out.println("found " + x))
    .orElse(() -> System.out.println("NOT FOUND"));

Se você pode usar apenas o Java 8 ou inferior:

1) se você não tem spring-dataa melhor maneira até agora é:

opt.<Runnable>map(param -> () -> System.out.println(param))
      .orElse(() -> System.out.println("no-param-specified"))
      .run();

Agora eu sei que não é tão legível e até difícil de entender para alguém, mas parece bom para mim pessoalmente e não vejo outra maneira fluente e agradável para este caso.

2) se você tiver sorte e puder usar spring-datada melhor maneira, é Opcional # ifPresentOrElse :

Optionals.ifPresentOrElse(opt, System.out::println,
      () -> System.out.println("no-param-specified"));

Se você pode usar o Java 9, definitivamente deve usar:

opt.ifPresentOrElse(System.out::println,
      () -> System.out.println("no-param-specified"));

O comportamento descrito pode ser alcançado usando o Vavr (anteriormente conhecido como Javaslang), uma biblioteca funcional de objetos para Java 8+, que implementa a maioria das construções do Scala (sendo o Scala uma linguagem mais expressiva com um sistema do tipo mais rico construído na JVM). É uma biblioteca muito boa para adicionar aos seus projetos Java para escrever código funcional puro.

O Vavr fornece a Optionmônada que fornece funções para trabalhar com o tipo de opção, como:

• fold: para mapear o valor da opção nos dois casos (definido / vazio)
• onEmpty: permite executar uma Runnableopção quando estiver vazia
• peek: permite consumir o valor da opção (quando definido).
• e também é, Serializablepelo contrário, o Optionalque significa que você pode usá-lo com segurança como argumento do método e membro da instância.

A opção segue as leis da mônada diferentes da "pseudo-mônada" opcional do Java e fornece uma API mais rica. E é claro que você pode fazer isso a partir de um Java opcional (e vice-versa):Option.ofOptional(javaOptional) vice versa –Vavr está focado na interoperabilidade.

Indo para o exemplo:

// AWESOME Vavr functional collections (immutable for the gread good :)
// fully convertible to Java's counterparts.
final Map<String, String> map = Map("key1", "value1", "key2", "value2");

final Option<String> opt = map.get("nonExistentKey"); // you're safe of null refs!

final String result = opt.fold(
        () -> "Not found!!!",                // Option is None
        val -> "Found the value: " + val     // Option is Some(val)
);

Leitura adicional

Referência nula, o erro de um bilhão de dólares

Nota: este é apenas um pequeno exemplo do que o Vavr oferece (correspondência de padrões, fluxos também conhecidos como listas de avaliação lenta, tipos monádicos, coleções imutáveis, ...).

Outra solução pode ser a seguinte:

É assim que você o usa:

    final Opt<String> opt = Opt.of("I'm a cool text");
    opt.ifPresent()
        .apply(s -> System.out.printf("Text is: %s\n", s))
        .elseApply(() -> System.out.println("no text available"));

Ou no caso de você, no caso de uso oposto, ser verdadeiro:

    final Opt<String> opt = Opt.of("This is the text");
    opt.ifNotPresent()
        .apply(() -> System.out.println("Not present"))
        .elseApply(t -> /*do something here*/);

Estes são os ingredientes:

1. Interface de função pouco modificada, apenas para o método "elseApply"
2. Aprimoramento opcional
3. Um pouco de enrolar :-)

A interface de função aprimorada "cosmeticamente".

@FunctionalInterface
public interface Fkt<T, R> extends Function<T, R> {

    default R elseApply(final T t) {
        return this.apply(t);
    }

}

E a classe Wrapper opcional para aprimoramento:

public class Opt<T> {

    private final Optional<T> optional;

    private Opt(final Optional<T> theOptional) {
        this.optional = theOptional;
    }

    public static <T> Opt<T> of(final T value) {
        return new Opt<>(Optional.of(value));
    }

    public static <T> Opt<T> of(final Optional<T> optional) {
        return new Opt<>(optional);
    }

    public static <T> Opt<T> ofNullable(final T value) {
        return new Opt<>(Optional.ofNullable(value));
    }

    public static <T> Opt<T> empty() {
        return new Opt<>(Optional.empty());
    }

    private final BiFunction<Consumer<T>, Runnable, Void> ifPresent = (present, notPresent) -> {
        if (this.optional.isPresent()) {
            present.accept(this.optional.get());
        } else {
            notPresent.run();
        }
        return null;
    };

   private final BiFunction<Runnable, Consumer<T>, Void> ifNotPresent = (notPresent, present) -> {
        if (!this.optional.isPresent()) {
            notPresent.run();
        } else {
            present.accept(this.optional.get());
        }
        return null;
    };

    public Fkt<Consumer<T>, Fkt<Runnable, Void>> ifPresent() {
        return Opt.curry(this.ifPresent);
    }

    public Fkt<Runnable, Fkt<Consumer<T>, Void>> ifNotPresent() {
        return Opt.curry(this.ifNotPresent);
    }

    private static <X, Y, Z> Fkt<X, Fkt<Y, Z>> curry(final BiFunction<X, Y, Z> function) {
        return (final X x) -> (final Y y) -> function.apply(x, y);
    }
}

Isso deve funcionar e pode servir como um modelo básico de como lidar com esses requisitos.

A idéia básica aqui é a seguir. Em um mundo de programação de estilo não funcional, você provavelmente implementaria um método com dois parâmetros, onde o primeiro é um tipo de código executável que deve ser executado caso o valor esteja disponível e o outro parâmetro é o código executável que deve ser executado caso o O valor não está disponível. Para melhor legibilidade, você pode usar o curring para dividir a função de dois parâmetros em duas funções de um parâmetro cada. Foi o que basicamente fiz aqui.

Dica: Opt também fornece o outro caso de uso em que você deseja executar um trecho de código, caso o valor não esteja disponível. Isso também pode ser feito via Optional.filter.stuff, mas achei muito mais legível.

Espero que ajude!

Boa programação :-)

Caso você queira armazenar o valor:

Pair.of<List<>, List<>> output = opt.map(details -> Pair.of(details.a, details.b))).orElseGet(() -> Pair.of(Collections.emptyList(), Collections.emptyList()));

Supondo que você tenha uma lista e evitando o isPresent()problema (relacionado aos opcionais), você pode usar .iterator().hasNext()para verificar se não está presente.