Stile funzionale di Java. Optional.ifPresent e if-not-Present?

In Java 8, voglio fare qualcosa su un Optionaloggetto se è presente e fare un'altra cosa se non è presente.

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

Questo non è uno "stile funzionale", comunque.

Optionalha un ifPresent()metodo, ma non riesco a concatenare un orElse()metodo.

Pertanto, non posso scrivere:

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

In risposta a @assylias, non credo funzioni Optional.map()per il seguente 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;
});

In questo caso, quando optè presente, aggiorno la sua proprietà e salvo nel database. Quando non è disponibile, ne creo uno nuovo obje lo salvo nel database.

Nota nei due lambda che devo tornare null.

Ma quando optè presente, verranno eseguiti entrambi i lambda. objverrà aggiornato e un nuovo oggetto verrà salvato nel database. Ciò è dovuto return nullalla prima lambda. E orElseGet()continuerà a essere eseguito.

Per me la risposta di @Dane White è OK, prima non mi piaceva usare Runnable ma non sono riuscito a trovare alternative, qui un'altra implementazione ho preferito di più

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

Poi :

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

Aggiornamento 1:

la soluzione di cui sopra per il modo tradizionale di sviluppo quando si ha il valore e si desidera elaborarlo, ma cosa succede se voglio definire la funzionalità e l'esecuzione sarà quindi, controllare il miglioramento sotto;

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

Quindi potrebbe essere usato come:

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

In questo nuovo codice hai 3 cose:

1. può definire la funzionalità prima dell'esistente dell'oggetto facile.
2. non creando la rifrazione degli oggetti per ogni Opzionale, solo uno, hai così meno memoria e meno GC.
3. sta implementando il consumatore per un migliore utilizzo con altri componenti.

a proposito ora il suo nome è più descrittivo in realtà è Consumatore>

Se si utilizza Java 9+, è possibile utilizzare il ifPresentOrElse()metodo:

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

Java 9 introduce

ifPresentOrElse se è presente un valore, esegue l'azione specificata con il valore, altrimenti esegue l'azione data vuota.

Vedi eccellente opzionale nel cheat sheet di Java 8 .

Fornisce tutte le risposte per la maggior parte dei casi d'uso.

Breve riassunto di seguito

ifPresent () - fare qualcosa quando è impostato Opzionale

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

filter () - rifiuta (filtra) alcuni valori opzionali.

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

map () - trasforma il valore se presente

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

orElse () / orElseGet () - svuotando Facoltativo al valore predefinito T

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

orElseThrow () - lancia pigramente eccezioni su vuoto Opzionale

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

Un'alternativa è:

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

Non penso che migliora la leggibilità però.

O come suggerito Marko, usa un operatore ternario:

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

Un'altra soluzione sarebbe quella di utilizzare le funzioni di ordine superiore come segue

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

Non c'è un ottimo modo per farlo fuori dalla scatola. Se si desidera utilizzare la sintassi più pulita su base regolare, è possibile creare una classe di utilità per aiutare:

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

Quindi puoi utilizzare un'importazione statica altrove per ottenere una sintassi vicina a ciò che stai cercando:

import static com.example.OptionalEx.ifPresent;

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

Se è possibile utilizzare solo Java 8 o precedente:

1) se non hai spring-datafinora il modo migliore è:

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

Ora so che non è così leggibile e nemmeno difficile da capire per qualcuno, ma mi sembra a posto per me personalmente e non vedo un altro modo fluente per questo caso.

2) se sei abbastanza fortunato e puoi usare spring-datail modo migliore è Optionals # ifPresentOrElse :

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

Se puoi usare Java 9, dovresti assolutamente andare con:

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

Il comportamento descritto può essere ottenuto usando Vavr (precedentemente noto come Javaslang), una libreria oggetto-funzionale per Java 8+, che implementa la maggior parte dei costrutti Scala (essendo Scala un linguaggio più espressivo con un sistema di tipo più ricco basato su JVM). È un'ottima libreria da aggiungere ai tuoi progetti Java per scrivere codice funzionale puro.

Vavr fornisce la Optionmonade che fornisce funzioni per lavorare con il tipo Opzione come:

• fold: per mappare il valore dell'opzione su entrambi i casi (definito / vuoto)
• onEmpty: consente di eseguire un Runnablequando l'opzione è vuota
• peek: consente di consumare il valore dell'opzione (quando definita).
• ed è anche Serializableal contrario il Optionalche significa che puoi tranquillamente usarlo come argomento del metodo e membro di istanza.

L'opzione segue le leggi della monade in modo diverso dalla "pseudo-monade" facoltativa di Java e fornisce un'API più ricca. E ovviamente puoi farlo da un Java opzionale (e viceversa): Option.ofOptional(javaOptional)–Vavr è focalizzato sull'interoperabilità.

Andando all'esempio:

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

Ulteriori letture

Riferimento nullo, errore di miliardi di dollari

NB Questo è solo un piccolo esempio di ciò che offre Vavr (pattern matching, stream aka liste valutate pigre, tipi monadici, raccolte immutabili, ...).

Un'altra soluzione potrebbe essere la seguente:

Ecco come lo usi:

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

O nel caso in cui il caso d'uso opposto sia vero:

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

Questi sono gli ingredienti:

1. Interfaccia di funzione leggermente modificata, solo per il metodo "elseApply"
2. Miglioramento opzionale
3. Un po 'di curring :-)

L'interfaccia funzionale "esteticamente" migliorata.

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

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

}

E la classe wrapper opzionale per il miglioramento:

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

Questo dovrebbe fare il trucco e potrebbe servire da modello di base su come gestire tali requisiti.

L'idea di base qui sta seguendo. In un mondo di programmazione di stile non funzionale probabilmente implementereste un metodo che prende due parametri in cui il primo è un tipo di codice eseguibile che dovrebbe essere eseguito nel caso in cui il valore sia disponibile e l'altro parametro sia il codice eseguibile che dovrebbe essere eseguito nel caso in cui il il valore non è disponibile. Per motivi di migliore leggibilità, è possibile utilizzare il curring per dividere la funzione di due parametri in due funzioni di un parametro ciascuno. Questo è quello che ho praticamente fatto qui.

Suggerimento: Opt fornisce anche l'altro caso d'uso in cui si desidera eseguire un pezzo di codice nel caso in cui il valore non sia disponibile. Questo potrebbe essere fatto anche tramite Optional.filter.stuff ma l'ho trovato molto più leggibile.

Spero che aiuti!

Buona programmazione :-)

Nel caso in cui desideri memorizzare il valore:

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

Supponendo di avere un elenco ed evitare il isPresent()problema (relativo agli optionals), è possibile utilizzare .iterator().hasNext()per verificare se non presente.