Javaで最初のnullでない値を取得するにはどうすればよいですか？

SQLのCOALESCE関数に相当するJavaはありますか？つまり、いくつかの変数の最初のnull以外の値を返す方法はありますか？

例えば

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

私は何とかの最初のnull以外の値を返します声明を持ちたいa、bと、cこの場合には、それが戻ってくる- b、または4.4。（sqlメソッドのようなもの-return COALESCE(a,b,c)）。私はそれを次のようなもので明示的に行うことができることを知っています：

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

しかし、これを実現するための組み込みの受け入れられた機能があるのか​​と思いました。

いいえ、ありません。

あなたが得ることができる最も近いものは：

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

効率的な理由から、一般的なケースは次のように処理できます。

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.of(T...).filter(Objects::nonNull).findFirst().orElse(null)

チェックする変数が2つだけあり、Guavaを使用している場合は、 MoreObjects.firstNonNull（T first、T second）を。

テストする参照が2つしかなく、Java 8を使用している場合は、

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

静的オプションをインポートする場合、式は悪くありません。

残念ながら、「いくつかの変数」を使用したケースは、Optionalメソッドでは不可能です。代わりに以下を使用できます。

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の答えに続いて、オーバーロードされた関数を呼び出すことにより、効率的なバージョンでの一部の繰り返しを排除できます。

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

この状況では、いくつかのプリプロセッサが必要です。なぜなら、最初のnullではない値を選択する関数（静的メソッド）を作成すると、すべての項目が評価されるからです。一部の項目がメソッド呼び出しである場合は問題があります（時間のかかるメソッド呼び出しである可能性があります）。また、このメソッドは、その前のアイテムがnullでない場合でも呼び出されます。

このようないくつかの機能

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

使用する必要がありますが、バイトコードにコンパイルする前に、この「コアレス関数」の使用法を見つけ、それを次のような構造に置き換えるプリプロセッサが必要です

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

アップデート2014-09-02：

Java 8とLambdasのおかげで、Javaで真の融合を実現できる可能性があります。重要な機能を含む：特定の式は必要な場合にのみ評価されます。以前の式がnullでない場合、次の式は評価されません（メソッドは呼び出されず、計算またはディスク/ネットワーク操作は行われません）。

Java 8：合体–hledámeneNULLovéhodnoty – についての記事を書きました（チェコ語で書かれていますが、コード例が誰にとっても理解できることを願っています）。

グアバでできること：

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

両方の場合NPEを投げないaとbされていますnull。

編集：私は間違っていました、それはNPEをスローします。MichalČizmaziaがコメントした正しい方法は次のとおりです。

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

完全を期すために、「いくつかの変数」のケースは実際には可能ですが、エレガントではありません。たとえば、変数のためにo、pとq：

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

使用に注意してくださいorElseGet()ケースに参加しているo、pと、qいずれかの高価なまたは望ましくない副作用を持つ変数が、式ではありません。

最も一般的なケースでは 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

これは、過度に長い式を生成する可能性があります。ただし、のない世界に移動しようとしている場合は、単純にではなくnull、v[i]おそらくすでにタイプOptional<String>になっていますString。この場合、

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

または式の場合：

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

さらに、あなたはまた、機能的、宣言型スタイルに移動している場合o、pおよびqタイプでなければなりませんSupplier<String>のように：

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

そして、全体coalesceは単純にに減少しo.get()ます。

より具体的な例として：

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()、およびageFromInput()すでに戻ってくるOptional<Integer>当然、。

そして、に満足するか、単ににcoalesceなります。effectiveAge.get()effectiveAgeSupplier<Integer>

IMHO、Java 8では、特に複雑なケースでは非常に自己説明的で効率的であるため、このような構造のコードがますます多く見られます。

1回だけLazy<T>呼び出すSupplier<T>が、遅延のクラスと、定義の一貫性Optional<T>（つまりOptional<T>- Optional<T>演算子、またはSupplier<Optional<T>>）が欠けているのを見逃しています。

あなたはこれを試すことができます：

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

この回答に基づく

高価な方法の評価を避けたい場合は、サプライヤを使用してみませんか？

このような：

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

そして、それを次のように使用します：

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

また、2つ、3つ、または4つの引数を持つ呼び出しにオーバーロードされたメソッドを使用することもできます。

さらに、次のようなストリームを使用することもできます。

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

どうですか：

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

Java ArrayListはnullエントリを便利に許可し、この式は考慮されるオブジェクトの数に関係なく一貫しています。（この形式では、考慮されるすべてのオブジェクトは同じタイプである必要があります。）

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