Java'da ilk null olmayan değeri nasıl elde edebilirim?

SQL COALESCEişlevinin Java eşdeğeri var mı? Yani, birkaç değişkenin ilk null olmayan değerini döndürmenin bir yolu var mı?

Örneğin

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

Bir şekilde ilk boş olmayan bir değer dönecektir bir açıklama yapmak istiyorum a, bve c- bu durumda, bu dönecekti bveya 4.4. (Sql yöntemi gibi bir şey - dönüş COALESCE(a,b,c)). Açıkça böyle bir şeyle yapabileceğimi biliyorum:

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

Ama bunu gerçekleştirmek için yerleşik, kabul edilmiş herhangi bir işlev olup olmadığını merak ettim.

Hayır, yok.

Alabileceğiniz en yakın şey:

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

Etkili nedenlerden dolayı, yaygın vakaları aşağıdaki gibi ele alabilirsiniz:

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 Akışı

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

Kontrol edilecek yalnızca iki değişken varsa ve Guava kullanıyorsanız, MoreObjects.firstNonNull (önce T, T saniye) kullanabilirsiniz .

Sınamak için yalnızca iki başvuru varsa ve Java 8 kullanıyorsanız

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

Statik İsteğe Bağlı içe aktarırsanız ifade çok kötü değil.

Ne yazık ki "birkaç değişkenli" durumunuz İsteğe bağlı bir yöntemle mümkün değildir. Bunun yerine şunları kullanabilirsiniz:

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

LES2'nin cevabından sonra, aşırı yüklenmiş fonksiyonu çağırarak verimli versiyondaki bazı tekrarları ortadan kaldırabilirsiniz:

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

Bu durum bazı önişlemciler gerektirir. Çünkü null olmayan ilk değeri seçen bir işlev (statik yöntem) yazarsanız, tüm öğeleri değerlendirir. Bazı öğelerin yöntem çağrısı olması sorun olur (zaman pahalı yöntem çağrıları olabilir). Ve bu yöntemler, önlerindeki herhangi bir öğe boş olmasa bile çağrılır.

Bunun gibi bazı işlevler

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

kullanılmalıdır, ancak bayt kodunu derlemeden önce bu “birleşme fonksiyonunun” kullanımlarını bulan ve onun yerine

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

2014-09-02 Güncellemesi:

Java 8 ve Lambdas sayesinde Java'da gerçek bir birleşim var! Önemli özellik dahil: belirli ifadeler yalnızca gerektiğinde değerlendirilir - eğer daha önce boş değilse, aşağıdaki ifadeler değerlendirilmez (yöntemler çağrılmaz, hesaplama veya disk / ağ işlemleri yapılmaz).

Bu konuda bir makale yazdım Java 8: coalesce - hledáme neNULLové hodnoty - (Çekçe yazılmış, ancak umarım kod örnekleri herkes için anlaşılabilir).

Guava ile şunları yapabilirsiniz:

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

Her iki takdirde NPE atmaz hangi ave bvardır null.

EDIT: Yanılmışım, NPE atıyor. Michal mazizmazia'nın yorumladığı gibi :

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

Tam olması için, "çok değişkenli" durum gerçekten de mümkün olmasa da mümkün. Örneğin, değişkenlerin o, pve q:

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

Dikkatini çekerim orElseGet()bakılırken o, pve qdeğişkenler ancak ifadeleri pahalı ya da istenmeyen yan etkiler ile ya da değildir.

En genel durumda 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

Bu, aşırı uzun ifadeler üretebilir. Onsuz bir dünyaya taşımak için çalışıyoruz Ancak, nulldaha sonra v[i]büyük olasılıkla zaten türdedir Optional<String>basitçe aksine, String. Bu durumda,

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

veya ifadeler söz konusu olduğunda:

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

Ayrıca fonksiyonel-bildirge stiline hareket ediyor Dahası, eğer o, pve qtipte olmalıdır Supplier<String>gibi:

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

Ve sonra bütün coalescebasitçe azalır o.get().

Daha somut bir örnek için:

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()ve ageFromInput()zaten Optional<Integer>doğal olarak geri dönecekti .

Ve sonra coalesceolur effectiveAge.get()ya da sadece bir effectiveAgeile mutlu olursak Supplier<Integer>.

IMHO, Java 8 ile daha fazla kodun bu şekilde yapılandırıldığını göreceğiz, çünkü aynı zamanda son derece açıklayıcı ve verimli, özellikle daha karmaşık durumlarda.

Ben sadece bir kez, ama tembel olarak, yanı sıra (yani - operatörler, hatta ) tanımında tutarlılık Lazy<T>çağıran bir sınıf özledim .Supplier<T>Optional<T>Optional<T>Optional<T>Supplier<Optional<T>>

Bunu deneyebilirsiniz:

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

Bu yanıta dayanarak

Pahalı bir yöntemi değerlendirmekten kaçınmak istediğinizde tedarikçileri kullanmaya ne dersiniz?

Bunun gibi:

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

Ve sonra böyle kullanmak:

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

İki, üç veya dört bağımsız değişkeni olan çağrılar için aşırı yüklenmiş yöntemleri de kullanabilirsiniz.

Ayrıca, akışları aşağıdaki gibi bir şeyle de kullanabilirsiniz:

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

Nasıl olur:

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

Java ArrayList uygun şekilde null girişlere izin verir ve bu ifade dikkate alınacak nesne sayısına bakılmaksızın tutarlıdır. (Bu formda, dikkate alınan tüm nesnelerin aynı türden olması gerekir.)

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