Gaya fungsional Java 8's Opsional. Jika Ada dan Jika-Tidak-Ada?

Di Java 8, saya ingin melakukan sesuatu ke Optionalobjek jika ada, dan melakukan hal lain jika tidak ada.

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

Ini bukan 'gaya fungsional'.

Optionalmemiliki ifPresent()metode, tetapi saya tidak dapat mengaitkan orElse()metode.

Jadi, saya tidak bisa menulis:

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

Sebagai balasan untuk @assylias, saya pikir ini tidak Optional.map()berfungsi untuk kasus berikut:

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

Dalam hal ini, ketika optada, saya memperbarui propertinya dan menyimpan ke database. Ketika tidak tersedia, saya membuat yang baru objdan menyimpan ke database.

Catatan dalam dua lambda saya harus kembali null.

Tetapi ketika optada, kedua lambda akan dieksekusi. objakan diperbarui, dan objek baru akan disimpan ke database. Ini karena return nulldalam lambda pertama. Dan orElseGet()akan terus dieksekusi.

Bagi saya jawaban dari @Dane White adalah OK, pertama saya tidak suka menggunakan Runnable tapi saya tidak bisa menemukan alternatif, di sini implementasi lain saya lebih suka

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

Kemudian :

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

Pembaruan 1:

solusi di atas untuk cara pengembangan tradisional ketika Anda memiliki nilai dan ingin memprosesnya, tetapi bagaimana jika saya ingin mendefinisikan fungsionalitas dan pelaksanaannya nanti, periksa peningkatan di bawah ini;

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

Kemudian bisa digunakan sebagai:

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

Dalam kode baru ini Anda memiliki 3 hal:

1. dapat mendefinisikan fungsionalitas sebelum ada objek yang mudah.
2. tidak membuat objek refrence untuk setiap Opsional, hanya satu, Anda memiliki lebih sedikit memori daripada kurang GC.
3. itu menerapkan konsumen untuk penggunaan yang lebih baik dengan komponen lain.

ngomong-ngomong sekarang namanya lebih deskriptif itu sebenarnya Consumer>

Jika Anda menggunakan Java 9+, Anda dapat menggunakan ifPresentOrElse()metode:

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

Java 9 memperkenalkan

ifPresentOrElse jika ada nilai, lakukan tindakan yang diberikan dengan nilai tersebut, jika tidak lakukan tindakan berbasis kosong yang diberikan.

Lihat Opsional yang sangat baik di lembar contekan Java 8 .

Ini memberikan semua jawaban untuk sebagian besar kasus penggunaan.

Ringkasan singkat di bawah ini

ifPresent () - lakukan sesuatu ketika Opsional diatur

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

filter () - tolak (filter out) nilai Opsional tertentu.

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

map () - mentransformasikan nilai jika ada

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

orElse () / orElseGet () - mengubah kosong Opsional ke standar T

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

orElseThrow () - malas melempar pengecualian pada Opsional kosong

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

Alternatifnya adalah:

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

Saya tidak berpikir itu meningkatkan keterbacaan.

Atau seperti yang disarankan Marko, gunakan operator ternary:

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

Solusi lain adalah dengan menggunakan fungsi tingkat tinggi sebagai berikut

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

Tidak ada cara yang bagus untuk melakukannya di luar kotak. Jika Anda ingin menggunakan sintaks pembersih Anda secara teratur, maka Anda dapat membuat kelas utilitas untuk membantu:

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

Kemudian Anda dapat menggunakan impor statis di tempat lain untuk mendapatkan sintaks yang mendekati apa yang Anda cari:

import static com.example.OptionalEx.ifPresent;

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

Jika Anda hanya dapat menggunakan Java 8 atau lebih rendah:

1) jika Anda tidak memiliki spring-datacara terbaik sejauh ini adalah:

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

Sekarang saya tahu itu tidak mudah dibaca dan bahkan sulit dimengerti untuk seseorang, tetapi terlihat baik bagi saya secara pribadi dan saya tidak melihat cara lain yang lancar untuk kasus ini.

2) jika Anda cukup beruntung dan Anda dapat menggunakan spring-datacara terbaik adalah Opsional # ifPresentOrElse :

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

Jika Anda dapat menggunakan Java 9, Anda harus menggunakan:

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

Perilaku yang dijelaskan dapat dicapai dengan menggunakan VAVR (sebelumnya dikenal sebagai Javaslang), perpustakaan fungsional-objek untuk Java 8+, yang mengimplementasikan sebagian besar konstruksi Scala (menjadi Scala bahasa yang lebih ekspresif dengan cara tipe sistem yang lebih kaya yang dibangun pada JVM). Ini adalah pustaka yang sangat bagus untuk ditambahkan ke proyek Java Anda untuk menulis kode fungsional murni.

Vavr menyediakan Optionmonad yang menyediakan fungsi untuk bekerja dengan jenis Opsi seperti:

• fold: untuk memetakan nilai opsi pada kedua kasus (ditentukan / kosong)
• onEmpty: memungkinkan untuk mengeksekusi Runnableopsi ketika kosong
• peek: memungkinkan untuk mengkonsumsi nilai opsi (saat ditentukan).
• dan itu juga Serializablesebaliknya Optionalyang berarti Anda dapat menggunakannya dengan aman sebagai argumen metode dan anggota contoh.

Opsi mengikuti hukum monad yang berbeda dengan "pseudo-monad" opsional Java dan menyediakan API yang lebih kaya. Dan tentu saja Anda dapat membuatnya dari Java's Optional (dan sebaliknya):Option.ofOptional(javaOptional) -Vavr berfokus pada interoperabilitas.

Pergi ke contoh:

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

Bacaan lebih lanjut

Referensi kosong, kesalahan miliar dolar

NB Ini hanya sedikit contoh dari apa yang ditawarkan Vavr (pencocokan pola, stream alias daftar malas yang dievaluasi, tipe monadik, koleksi tidak berubah, ...).

Solusi lain dapat mengikuti:

Ini adalah bagaimana Anda menggunakannya:

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

Atau jika Anda dalam kasus penggunaan sebaliknya adalah benar:

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

Ini bahannya:

1. Antarmuka Fungsi yang sedikit dimodifikasi, hanya untuk metode "elseApply"
2. Peningkatan opsional
3. Sedikit mengalir :-)

Antarmuka Fungsi yang ditingkatkan "secara kosmetik".

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

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

}

Dan kelas bungkus opsional untuk peningkatan:

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

Ini harus melakukan trik dan dapat berfungsi sebagai templat dasar bagaimana menangani persyaratan tersebut.

Ide dasar di sini adalah sebagai berikut. Dalam dunia pemrograman gaya non fungsional Anda mungkin akan menerapkan metode mengambil dua parameter di mana yang pertama adalah jenis kode runnable yang harus dieksekusi jika nilai tersedia dan parameter lainnya adalah kode runnable yang harus dijalankan jika nilai tidak tersedia. Demi keterbacaan yang lebih baik, Anda dapat menggunakan arus untuk membagi fungsi dua parameter menjadi dua fungsi masing-masing satu parameter. Inilah yang pada dasarnya saya lakukan di sini.

Petunjuk: Keikutsertaan juga menyediakan use case lain di mana Anda ingin mengeksekusi sepotong kode kalau-kalau nilainya tidak tersedia. Ini dapat dilakukan juga melalui Optional.filter.stuff tetapi saya menemukan ini jauh lebih mudah dibaca.

Semoga itu bisa membantu!

Pemrograman yang bagus :-)

Jika Anda ingin menyimpan nilai:

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

Misalkan Anda memiliki daftar dan menghindari isPresent()masalah (terkait dengan opsional) yang dapat Anda gunakan .iterator().hasNext()untuk memeriksa jika tidak ada.