Wie erhalte ich den ersten Nicht-Null-Wert in Java?

Gibt es ein Java-Äquivalent zur SQL- COALESCEFunktion? Gibt es eine Möglichkeit, den ersten Nicht-Null-Wert mehrerer Variablen zurückzugeben?

z.B

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

Ich möchte irgendwie eine Erklärung haben, die den ersten Nicht-Null - Wert von wird zurückkehren a, bund c- in diesem Fall würde es zurückgeben b, oder 4.4. (So ​​etwas wie die SQL-Methode - return COALESCE(a,b,c)). Ich weiß, dass ich es explizit mit so etwas wie:

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

Aber ich fragte mich, ob es eine eingebaute, akzeptierte Funktion gab, um dies zu erreichen.

Nein, gibt es nicht.

Der nächste, den Sie bekommen können, ist:

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

Aus effizienten Gründen können Sie die häufigsten Fälle wie folgt behandeln:

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)

Wenn nur zwei Variablen überprüft werden müssen und Sie Guava verwenden, können Sie MoreObjects.firstNonNull (T first, T second) verwenden .

Wenn nur zwei Referenzen getestet werden müssen und Sie Java 8 verwenden, können Sie diese verwenden

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

Wenn Sie statisch importieren Optional ist der Ausdruck nicht schlecht.

Leider ist Ihr Fall mit "mehreren Variablen" mit einer optionalen Methode nicht möglich. Stattdessen könnten Sie verwenden:

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

In Anlehnung an die Antwort von LES2 können Sie einige Wiederholungen in der effizienten Version vermeiden, indem Sie die überladene Funktion aufrufen:

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

Diese Situation erfordert einen Präprozessor. Wenn Sie eine Funktion (statische Methode) schreiben, die den ersten Wert ungleich Null auswählt, werden alle Elemente ausgewertet. Es ist problematisch, wenn es sich bei einigen Elementen um Methodenaufrufe handelt (dies können zeitaufwändige Methodenaufrufe sein). Und diese Methoden werden auch dann aufgerufen, wenn ein Element vor ihnen nicht null ist.

Einige funktionieren so

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

sollte verwendet werden, aber vor dem Kompilieren in Bytecode sollte es einen Präprozessor geben, der die Verwendung dieser „Koaleszenzfunktion“ findet und sie durch eine Konstruktion wie ersetzt

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

Update 02.09.2014:

Dank Java 8 und Lambdas besteht die Möglichkeit, dass Java wirklich zusammenwächst! Einschließlich der entscheidenden Funktion: Bestimmte Ausdrücke werden nur bei Bedarf ausgewertet. Wenn der frühere nicht null ist, werden die folgenden nicht ausgewertet (Methoden werden nicht aufgerufen, Berechnungen oder Festplatten- / Netzwerkoperationen werden nicht ausgeführt).

Ich habe einen Artikel darüber geschrieben Java 8: coalesce - hledáme neNULLové hodnoty - (geschrieben auf Tschechisch, aber ich hoffe, dass Codebeispiele für alle verständlich sind).

Mit Guava können Sie Folgendes tun:

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

was NPE nicht wirft, wenn beide aund bsind null.

EDIT: Ich habe mich geirrt, es wirft NPE. Der richtige Weg, wie von Michal Čizmazia kommentiert, ist:

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

Nur der Vollständigkeit halber ist der Fall "mehrere Variablen" zwar möglich, aber überhaupt nicht elegant. Zum Beispiel für Variablen o, pund q:

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

Bitte beachten Sie, dass Sie sich orElseGet()um den Fall kümmern omüssen p, dass qes sich nicht um Variablen handelt, sondern um Ausdrücke, die entweder teuer sind oder unerwünschte Nebenwirkungen haben.

Im allgemeinsten Fall 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

Dies kann zu lange Ausdrücke erzeugen. Wenn wir jedoch versuchen, uns in eine Welt ohne zu bewegen null, dann v[i]sind wir höchstwahrscheinlich schon vom Typ Optional<String>, im Gegensatz zu einfach String. In diesem Fall,

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

oder im Fall von Ausdrücken:

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

Wenn Sie darüber hinaus auch zu einem funktionellen-deklarativem Stil bewegen, o, p, und qsollte vom Typ sein , Supplier<String>wie in:

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

Und dann coalescereduziert sich das Ganze einfach auf o.get().

Für ein konkreteres Beispiel:

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()Und ageFromInput()würde schon zurückkehren Optional<Integer>, natürlich.

Und dann coalescewird das effectiveAge.get()oder einfach effectiveAgewenn wir mit einem zufrieden sind Supplier<Integer>.

IMHO, mit Java 8 werden wir immer mehr Code sehen, der so strukturiert ist, da er extrem selbsterklärend und gleichzeitig effizient ist, insbesondere in komplexeren Fällen.

Ich vermisse eine Klasse Lazy<T>, die Supplier<T>nur einmal, aber träge, sowie Konsistenz in der Definition von Optional<T>(dh Optional<T>- Optional<T>Operatoren oder sogar Supplier<Optional<T>>) aufruft .

Sie können dies versuchen:

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

Basierend auf dieser Antwort

Wie wäre es mit Lieferanten, wenn Sie die Bewertung einer teuren Methode vermeiden möchten?

So was:

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

Und dann benutze ich es so:

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

Sie können auch überladene Methoden für die Aufrufe mit zwei, drei oder vier Argumenten verwenden.

Darüber hinaus können Sie auch Streams mit folgenden Elementen verwenden:

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

Wie wäre es mit:

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

Java ArrayList erlaubt bequemerweise Null-Einträge und dieser Ausdruck ist unabhängig von der Anzahl der zu berücksichtigenden Objekte konsistent. (In dieser Form müssen alle betrachteten Objekte vom gleichen Typ sein.)

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