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

Question

¿Hay un equivalente Java de la función COALESCE de SQL? 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, b, y c - en este caso, sería volver b, o 4.4. (Algo así como el método sql - devuelve COALESCE(a,b,c)). Sé que puedo hacerlo de forma explícita con algo como:

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

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

Answer 1

No, no lo hay.

Lo más cerca que se puede conseguir es:

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

Por razones de eficiencia, que puede manejar los casos más 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 ... 
} 

Answer 2

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

Answer 3

A raíz de la respuesta de les2, puede eliminar alguna repetición 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); 
} 

Answer 4

Si está usando Guava, puede usar MoreObjects.firstNonNull(T...).

Answer 5

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

Algunos función como esta

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

se debe utilizar antes de la compilación en código de bytes no debe ser un preprocesador que encuentran usos de esta función “se unen” y lo reemplaza con la construcción como

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

Actualización 2014-09-02:

Gracias a Java 8 y Lambdas hay possibi ¡La verdad es que se unen en Java! Incluyendo la característica crucial: las expresiones particulares se evalúan solo cuando es necesario; si las anteriores no son nulas, las siguientes no se evalúan (los métodos no se invocan, las operaciones de computación o de disco/red no se realizan).

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

Answer 6

Con guayaba que puede hacer:

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

que no tirar NPE si ambos a y b son null.

EDITAR: Estaba equivocado, arroja NPE. La forma correcta como han comentado en Michal Čizmazia es:

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

Answer 7

Apache Commons Lang 3

ObjectUtils.firstNonNull(T...)

Java 8 Corriente

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

Answer 8

Si sólo hay dos referencias para probar y está usando Java 8, podría 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.

Desafortunadamente su caso con "varias variables" no es posible con un método opcional. En su lugar, puede 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 

Answer 9

Solo por completitud, el caso de "varias variables" es de hecho posible, aunque no elegante en absoluto. Por ejemplo, para las variables o, p y q:

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

Tenga en cuenta el uso de orElseGet() asistir al caso de que o, p y q 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 largo. Sin embargo, si estamos tratando de movernos a un mundo sin null, entonces v[i] probablemente ya sean del tipo Optional<String>, en lugar de simplemente String. En este caso,

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

o en el caso de las 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 q debe 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 entonces todo el coalesce reduce simplemente a o.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() ya se volverían Optional<Integer>, naturalmente.

Y entonces el coalesce convierte effectiveAge.get() o simplemente effectiveAge si estamos contentos con un Supplier<Integer>.

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

no se pierda una clase Lazy<T> que invoca un Supplier<T> sólo una vez, pero con pereza, así como la coherencia en la definición de Optional<T> (es decir Optional<T> - Optional<T> operadores, o incluso Supplier<Optional<T>>).

Answer 10

¿Qué tal:

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

Java ArrayList permite convenientemente entradas nulas y esta expresión es constante independientemente de la cantidad de objetos a considerar. (En esta forma, todos los objetos considerados tienen que ser del mismo tipo.)

Answer 11

Usted puede intentar esto:

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

Basado en Christian Ullenboom respuesta