Bagaimana cara mendapatkan nilai non-null pertama di Java?

Apakah ada Java yang setara dengan COALESCEfungsi SQL ? Yaitu, adakah cara untuk mengembalikan nilai non-null pertama dari beberapa variabel?

misalnya

Double a = null;
Double b = 4.4;
Double c = null;

Saya ingin entah bagaimana memiliki pernyataan yang akan mengembalikan nilai non-null pertama a, bdan c- dalam hal ini, itu akan kembali b, atau 4,4. (Sesuatu seperti metode sql - return COALESCE(a,b,c)). Saya tahu bahwa saya dapat melakukannya secara eksplisit dengan sesuatu seperti:

return a != null ? a : (b != null ? b : c)

Tetapi saya bertanya-tanya apakah ada fungsi bawaan yang diterima untuk melakukan ini.

Tidak, tidak ada.

Yang paling dekat yang bisa Anda dapatkan adalah:

public static <T> T coalesce(T ...items) {
    for(T i : items) if(i != null) return i;
    return null;
}

Untuk alasan yang efisien, Anda dapat menangani kasus umum sebagai berikut:

public static <T> T coalesce(T a, T b) {
    return a == null ? b : a;
}
public static <T> T coalesce(T a, T b, T c) {
    return a != null ? a : (b != null ? b : c);
}
public static <T> T coalesce(T a, T b, T c, T d) {
    return ...
}

Apache Commons Lang 3

ObjectUtils.firstNonNull(T...)

Java 8 Stream

Stream.of(T...).filter(Objects::nonNull).findFirst().orElse(null)

Jika hanya ada dua variabel untuk diperiksa dan Anda menggunakan Guava, Anda dapat menggunakan MoreObjects.firstNonNull (T pertama, T kedua) .

Jika hanya ada dua referensi untuk diuji dan Anda menggunakan Java 8, Anda bisa menggunakannya

Object o = null;
Object p = "p";
Object r = Optional.ofNullable( o ).orElse( p );
System.out.println( r );   // p

Jika Anda mengimpor statis Opsional, ekspresi tidak terlalu buruk.

Sayangnya kasus Anda dengan "beberapa variabel" tidak dimungkinkan dengan metode-Opsional. Sebagai gantinya Anda dapat menggunakan:

Object o = null;
Object p = null;
Object q = "p";

Optional<Object> r = Stream.of( o, p, q ).filter( Objects::nonNull ).findFirst();
System.out.println( r.orElse(null) );   // p

Mengikuti dari jawaban LES2, Anda dapat menghilangkan beberapa pengulangan dalam versi efisien, dengan memanggil fungsi kelebihan beban:

public static <T> T coalesce(T a, T b) {
    return a != null ? a : b;
}
public static <T> T coalesce(T a, T b, T c) {
    return a != null ? a : coalesce(b,c);
}
public static <T> T coalesce(T a, T b, T c, T d) {
    return a != null ? a : coalesce(b,c,d);
}
public static <T> T coalesce(T a, T b, T c, T d, T e) {
    return a != null ? a : coalesce(b,c,d,e);
}

Situasi ini memerlukan beberapa preprosesor. Karena jika Anda menulis fungsi (metode statis) yang memilih yang pertama bukan nilai nol, itu mengevaluasi semua item. Masalah jika beberapa item adalah panggilan metode (mungkin panggilan metode waktu yang mahal). Dan metode ini dipanggil bahkan jika setiap item sebelum mereka bukan nol.

Beberapa fungsinya seperti ini

public static <T> T coalesce(T ...items) …

harus digunakan tetapi sebelum mengkompilasi ke dalam kode byte harus ada preprocessor yang menemukan penggunaan "fungsi penggabungan" ini dan menggantinya dengan konstruksi seperti

a != null ? a : (b != null ? b : c)

Pembaruan 2014-09-02:

Berkat Java 8 dan Lambdas ada kemungkinan untuk memiliki perpaduan sejati di Jawa! Termasuk fitur penting: ekspresi tertentu dievaluasi hanya bila diperlukan - jika sebelumnya tidak nol, maka yang berikut tidak dievaluasi (metode tidak dipanggil, operasi komputasi atau disk / jaringan tidak dilakukan).

Saya menulis artikel tentang hal itu Java 8: coalesce - hledáme neNULLové hodnoty - (ditulis dalam bahasa Ceko, tapi saya harap contoh kode dapat dimengerti oleh semua orang).

Dengan Jambu Biji, Anda bisa melakukannya:

Optional.fromNullable(a).or(b);

yang tidak melempar NPE jika keduanya adan bsedang null.

EDIT: Saya salah, itu melempar NPE. Cara yang benar seperti yang dikomentari oleh Michal Čizmazia adalah:

Optional.fromNullable(a).or(Optional.fromNullable(b)).orNull();

Hanya untuk kelengkapan, kasus "beberapa variabel" memang mungkin, meskipun tidak elegan sama sekali. Misalnya, untuk variabel o, pdan q:

Optional.ofNullable( o ).orElseGet(()-> Optional.ofNullable( p ).orElseGet(()-> q ) )

Harap dicatat penggunaan orElseGet()menghadiri untuk kasus yang o, pdan qtidak variabel tapi ekspresi baik mahal atau dengan yang tidak diinginkan efek samping.

Dalam kasus yang paling umum coalesce(e[1],e[2],e[3],...,e[N])

coalesce-expression(i) ==  e[i]  when i = N
coalesce-expression(i) ==  Optional.ofNullable( e[i] ).orElseGet(()-> coalesce-expression(i+1) )  when i < N

Ini bisa menghasilkan ekspresi terlalu lama. Namun, jika kita mencoba untuk pindah ke dunia tanpa null, maka v[i]kemungkinan besar sudah bertipe Optional<String>, bukan hanya String. Pada kasus ini,

result= o.orElse(p.orElse(q.get())) ;

atau dalam hal ekspresi:

result= o.orElseGet(()-> p.orElseGet(()-> q.get() ) ) ;

Selain itu, jika Anda juga pindah ke gaya fungsional-deklaratif, o, p, dan qharus dari jenis Supplier<String>seperti di:

Supplier<String> q= ()-> q-expr ;
Supplier<String> p= ()-> Optional.ofNullable(p-expr).orElseGet( q ) ;
Supplier<String> o= ()-> Optional.ofNullable(o-expr).orElseGet( p ) ;

Dan kemudian keseluruhan coalescedikurangi menjadi o.get().

Untuk contoh yang lebih konkret:

Supplier<Integer> hardcodedDefaultAge= ()-> 99 ;
Supplier<Integer> defaultAge= ()-> defaultAgeFromDatabase().orElseGet( hardcodedDefaultAge ) ;
Supplier<Integer> ageInStore= ()-> ageFromDatabase(memberId).orElseGet( defaultAge ) ;
Supplier<Integer> effectiveAge= ()-> ageFromInput().orElseGet( ageInStore ) ;

defaultAgeFromDatabase(),, ageFromDatabase()dan ageFromInput()sudah akan kembali Optional<Integer>, secara alami.

Dan kemudian coalescemenjadi effectiveAge.get()atau hanya effectiveAgejika kita senang dengan Supplier<Integer>.

IMHO, dengan Java 8 kita akan melihat semakin banyak kode terstruktur seperti ini, karena sangat jelas dan efisien pada saat yang sama, terutama dalam kasus yang lebih kompleks.

Saya melewatkan kelas Lazy<T>yang memanggil Supplier<T>hanya satu kali, tetapi malas, serta konsistensi dalam definisi Optional<T>(yaitu Optional<T>- Optional<T>operator, atau bahkan Supplier<Optional<T>>).

Anda dapat mencoba ini:

public static <T> T coalesce(T... t) {
    return Stream.of(t).filter(Objects::nonNull).findFirst().orElse(null);
}

Berdasarkan tanggapan ini

Bagaimana dengan menggunakan pemasok ketika Anda ingin menghindari mengevaluasi beberapa metode mahal?

Seperti ini:

public static <T> T coalesce(Supplier<T>... items) {
for (Supplier<T> item : items) {
    T value = item.get();
    if (value != null) {
        return value;
    }
    return null;
}

Dan kemudian menggunakannya seperti ini:

Double amount = coalesce(order::firstAmount, order::secondAmount, order::thirdAmount)

Anda juga dapat menggunakan metode kelebihan beban untuk panggilan dengan dua, tiga atau empat argumen.

Selain itu, Anda juga bisa menggunakan stream dengan sesuatu seperti ini:

public static <T> T coalesce2(Supplier<T>... s) {
    return Arrays.stream(s).map(Supplier::get).filter(Objects::nonNull).findFirst().orElse(null);
}

Bagaimana tentang:

firstNonNull = FluentIterable.from(
    Lists.newArrayList( a, b, c, ... ) )
        .firstMatch( Predicates.notNull() )
            .or( someKnownNonNullDefault );

Java ArrayList dengan mudah memungkinkan entri nol dan ekspresi ini konsisten terlepas dari jumlah objek yang dipertimbangkan. (Dalam bentuk ini, semua objek yang dipertimbangkan harus memiliki tipe yang sama.)

Object coalesce(Object... objects)
{
    for(Object o : object)
        if(o != null)
            return o;
    return null;
}