Come ottenere il primo valore non nullo in Java?

Esiste un equivalente Java della COALESCEfunzione SQL ? Cioè, c'è un modo per restituire il primo valore non nullo di più variabili?

per esempio

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

Voglio avere in qualche modo una dichiarazione che restituirà il primo valore non nullo di a, be c- in questo caso, che sarebbe tornato b, o 4.4. (Qualcosa come il metodo sql - return COALESCE(a,b,c)). So che posso farlo esplicitamente con qualcosa del tipo:

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

Ma mi chiedevo se ci fosse una funzione incorporata e accettata per raggiungere questo obiettivo.

No, non c'è.

Il più vicino che puoi ottenere è:

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

Per motivi efficienti, è possibile gestire i casi comuni come segue:

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)

Se ci sono solo due variabili da controllare e stai usando Guava, puoi usare MoreObjects.firstNonNull (T prima, T seconda) .

Se ci sono solo due riferimenti da testare e si sta utilizzando Java 8, è possibile utilizzare

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

Se si importa statico Opzionale, l'espressione non è troppo male.

Sfortunatamente il tuo caso con "diverse variabili" non è possibile con un metodo opzionale. Invece potresti usare:

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

Seguendo la risposta di LES2, è possibile eliminare alcune ripetizioni nella versione efficiente, chiamando la funzione sovraccaricata:

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

Questa situazione richiede alcuni preprocessori. Perché se si scrive una funzione (metodo statico) che seleziona il primo valore non nullo, valuta tutti gli elementi. È un problema se alcuni elementi sono chiamate di metodo (potrebbero essere chiamate di metodo costose in termini di tempo). E questi metodi vengono chiamati anche se qualsiasi elemento precedente non è nullo.

Alcuni funzionano in questo modo

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

dovrebbe essere usato ma prima di compilare in codice byte dovrebbe esserci un preprocessore che trova gli usi di questa "funzione di coalescenza" e lo sostituisce con una costruzione come

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

Aggiornamento 2014-09-02:

Grazie a Java 8 e Lambdas c'è la possibilità di avere una vera fusione in Java! Inclusa la caratteristica cruciale: determinate espressioni vengono valutate solo quando necessario - se una precedente non è nulla, le seguenti non vengono valutate (i metodi non vengono chiamati, il calcolo o le operazioni su disco / rete non vengono eseguite).

Ho scritto un articolo a riguardo Java 8: coalesce - hledáme neNULLové hodnoty - (scritto in ceco, ma spero che esempi di codice siano comprensibili per tutti).

Con Guava puoi fare:

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

che non genera NPE se entrambi ae lo bsono null.

EDIT: ho sbagliato, getta NPE. Il modo corretto come commentato da Michal Čizmazia è:

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

Solo per completezza, il caso "diverse variabili" è davvero possibile, sebbene non sia affatto elegante. Ad esempio, per le variabili o, pe q:

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

Si prega di notare l'uso del orElseGet()caso che o, pe qnon sono variabili ma espressioni o costose o con effetti collaterali indesiderati.

Nel caso più generale 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

Questo può generare espressioni eccessivamente lunghe. Tuttavia, se stiamo cercando di spostarci in un mondo senza null, allora v[i]molto probabilmente sono già di tipo Optional<String>, al contrario di semplicemente String. In questo caso,

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

o nel caso di espressioni:

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

Inoltre, se siete anche muovendo per uno stile funzionale-dichiarativa, o, p, e qdovrebbe essere di tipo Supplier<String>simile a:

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

E poi il tutto si coalesceriduce semplicemente a o.get().

Per un esempio più concreto:

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()e ageFromInput()sarebbe già tornato Optional<Integer>, naturalmente.

E poi coalescediventa effectiveAge.get()o semplicemente effectiveAgese siamo felici con a Supplier<Integer>.

IMHO, con Java 8 vedremo sempre più codice strutturato in questo modo, poiché è estremamente autoesplicativo ed efficiente allo stesso tempo, specialmente in casi più complessi.

Mi manca una classe Lazy<T>che invoca una Supplier<T>sola volta, ma pigramente, così come la coerenza nella definizione di Optional<T>(cioè Optional<T>- Optional<T>operatori, o anche Supplier<Optional<T>>).

Puoi provare questo:

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

Sulla base di questa risposta

Che ne dici di usare i fornitori quando vuoi evitare di valutare qualche metodo costoso?

Come questo:

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

E poi usandolo in questo modo:

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

È inoltre possibile utilizzare metodi sovraccaricati per le chiamate con due, tre o quattro argomenti.

Inoltre, puoi anche usare stream con qualcosa del genere:

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

Che ne dite di:

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

Java ArrayList consente convenientemente voci nulle e questa espressione è coerente indipendentemente dal numero di oggetti da considerare. (In questo modulo, tutti gli oggetti considerati devono essere dello stesso tipo.)

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