¿Cómo obtener el primer valor no nulo en Java?

¿Existe un equivalente Java de SQL COALESCE función ? Es decir, ¿hay alguna forma de devolver el primer valor no nulo de varias variables?

p.ej

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

Quiero tener de alguna manera una declaración que devolverá el primer valor no nulo de a, by c- en este caso, sería volver b, o 4.4. (Algo así como el método sql - return COALESCE(a,b,c)). Sé que puedo hacerlo explícitamente con algo como:

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

Pero me preguntaba si había alguna función incorporada y aceptada para lograr esto.

No, no hay

Lo más cercano que puede llegar es:

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

Por razones eficientes, puede manejar los casos comunes de la siguiente manera:

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)

Si solo hay dos variables para verificar y está usando Guava, puede usar MoreObjects.firstNonNull (T primero, T segundo) .

Si solo hay dos referencias para probar y está utilizando Java 8, puede usar

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

Si importa estática Opcional, la expresión no es tan mala.

Lamentablemente, su caso con "varias variables" no es posible con un método opcional. En su lugar, podría usar:

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

Siguiendo con la respuesta de LES2, puede eliminar algunas repeticiones en la versión eficiente, llamando a la función sobrecargada:

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

Esta situación requiere algún preprocesador. Porque si escribe una función (método estático) que selecciona el primer valor no nulo, evalúa todos los elementos. Es un problema si algunos elementos son llamadas a métodos (pueden ser llamadas a métodos costosos). Y se llama a estos métodos incluso si algún elemento antes de ellos no es nulo.

Algunas funciones como esta

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

debe usarse, pero antes de compilar en el código de bytes, debe haber un preprocesador que encuentre el uso de esta "función de fusión" y la reemplace con una construcción como

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

Actualización 2014-09-02:

¡Gracias a Java 8 y Lambdas existe la posibilidad de tener una verdadera fusión en Java! Incluyendo la característica crucial: las expresiones particulares se evalúan solo cuando es necesario; si una anterior no es nula, las siguientes no se evalúan (no se llaman métodos, no se realizan operaciones de cálculo o de disco / red).

Escribí un artículo al respecto Java 8: fusión - hledáme neNULLové hodnoty - (escrito en checo, pero espero que los ejemplos de código sean comprensibles para todos).

Con guayaba puedes hacer:

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

que no arroja NPE si ambos ay bson null.

EDITAR: Me equivoqué, arroja NPE. La forma correcta según lo comentado por Michal Čizmazia es:

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

Solo para completar, el caso de "varias variables" es realmente posible, aunque no es elegante en absoluto. Por ejemplo, para las variables o, py q:

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

Tenga en cuenta el uso de orElseGet()asistir al caso de que o, pyq no son variables sino expresiones caros o con efectos secundarios no deseados.

En el caso más general 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

Esto puede generar expresiones excesivamente largas. Sin embargo, si estamos tratando de mudarnos a un mundo sin él null, entonces v[i]lo más probable es que ya seamos de tipo Optional<String>, en lugar de simplemente String. En este caso,

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

o en el caso de expresiones:

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

Por otra parte, si también se está moviendo a un estilo funcional declarativa, o, p, y qdebe ser de tipo Supplier<String>como en:

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

Y luego todo se coalescereduce simplemente ao.get() .

Para un ejemplo más 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()Y ageFromInput()sería ya volverOptional<Integer> , naturalmente.

Y luego se coalesceconvierte effectiveAge.get()o simplemente effectiveAgesi estamos contentos con unSupplier<Integer> .

En mi humilde opinión, con Java 8 veremos más y más código estructurado de esta manera, ya que es extremadamente autoexplicativo y eficiente al mismo tiempo, especialmente en casos más complejos.

Echo de menos una clase Lazy<T>que invoca Supplier<T>solo una vez, pero perezosamente, así como la coherencia en la definición de Optional<T>(es decir Optional<T>, Optional<T>operadores, o incluso Supplier<Optional<T>>).

Puedes probar esto:

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

Basado en esta respuesta

¿Qué tal usar proveedores cuando quieres evitar evaluar algún método costoso?

Me gusta esto:

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

Y luego usarlo así:

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

También puede usar métodos sobrecargados para las llamadas con dos, tres o cuatro argumentos.

Además, también podría usar transmisiones con algo como esto:

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

Qué tal si:

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

Java ArrayList permite convenientemente entradas nulas y esta expresión es coherente independientemente del número de objetos a considerar. (De esta forma, todos los objetos considerados deben ser del mismo tipo).

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