Comment obtenir la première valeur non nulle en Java?

Existe-t-il un équivalent Java de la COALESCEfonction SQL ? Autrement dit, existe-t-il un moyen de renvoyer la première valeur non nulle de plusieurs variables?

par exemple

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

Je veux en quelque sorte une déclaration qui renverra la première valeur non nulle a, bet c- dans ce cas, il retournerait bou 4.4. (Quelque chose comme la méthode sql - return COALESCE(a,b,c)). Je sais que je peux le faire explicitement avec quelque chose comme:

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

Mais je me suis demandé s'il y avait une fonction intégrée et acceptée pour accomplir cela.

Non, il n'y en a pas.

Le plus proche que vous pouvez obtenir est:

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

Pour des raisons d'efficacité, vous pouvez gérer les cas courants comme suit:

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...)

Flux Java 8

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

S'il n'y a que deux variables à vérifier et que vous utilisez Guava, vous pouvez utiliser MoreObjects.firstNonNull (T d'abord, T ensuite) .

S'il n'y a que deux références à tester et que vous utilisez Java 8, vous pouvez utiliser

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

Si vous importez statique Facultatif, l'expression n'est pas trop mauvaise.

Malheureusement, votre cas avec "plusieurs variables" n'est pas possible avec une méthode optionnelle. Au lieu de cela, vous pouvez utiliser:

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

Suite à la réponse de LES2, vous pouvez éliminer certaines répétitions dans la version efficace, en appelant la fonction surchargée:

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

Cette situation nécessite un préprocesseur. Parce que si vous écrivez une fonction (méthode statique) qui sélectionne la première valeur non nulle, elle évalue tous les éléments. C'est un problème si certains éléments sont des appels de méthode (peuvent être des appels de méthode coûteux en temps). Et ces méthodes sont appelées même si un élément avant elles n'est pas nul.

Certains fonctionnent comme ça

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

devrait être utilisé mais avant la compilation en code octet, il devrait y avoir un préprocesseur qui trouve les utilisations de cette «fonction de coalescence» et la remplace par une construction comme

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

Mise à jour 02/09/2014:

Grâce à Java 8 et Lambdas, il est possible d'avoir une véritable fusion en Java! Y compris la caractéristique cruciale: les expressions particulières ne sont évaluées que lorsque cela est nécessaire - si la précédente n'est pas nulle, les suivantes ne sont pas évaluées (les méthodes ne sont pas appelées, le calcul ou les opérations disque / réseau ne sont pas effectués).

J'ai écrit un article à ce sujet Java 8: coalesce - hledáme neNULLové hodnoty - (écrit en tchèque, mais j'espère que les exemples de code sont compréhensibles pour tout le monde).

Avec Guava, vous pouvez faire:

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

qui ne jette pas de NPE si les deux aet bsontnull .

EDIT: je me suis trompé, il jette NPE. La bonne manière, comme le commente Michal Čizmazia, est:

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

Pour être complet, le cas «plusieurs variables» est en effet possible, mais pas du tout élégant. Par exemple, pour les variables o, pet q:

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

Veuillez noter qu'il est utile de orElseGet()s'occuper du cas qui o, pet qne sont pas des variables mais des expressions coûteuses ou avec des effets secondaires indésirables.

Dans le cas le plus général 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

Cela peut générer des expressions excessivement longues. Cependant, si nous essayons de passer à un monde sans null, alors v[i]sont très probablement déjà de typeOptional<String> , par opposition à simplement String. Dans ce cas,

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

ou dans le cas d'expressions:

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

De plus, si vous prépare également à un style fonctionnel déclarative, o, pet qdevrait être de typeSupplier<String> comme dans:

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

Et puis le tout coalesce réduit simplement à o.get().

Pour un exemple plus concret:

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() et ageFromInput()reviendraient déjà Optional<Integer>, naturellement.

Et puis le coalescedevienteffectiveAge.get() ou simplement effectiveAgesi nous sommes satisfaits d'un Supplier<Integer>.

IMHO, avec Java 8, nous verrons de plus en plus de code structuré comme celui-ci, car il est extrêmement auto-explicatif et efficace en même temps, en particulier dans les cas plus complexes.

Je manque une classe Lazy<T>qui n'invoque Supplier<T>qu'une seule fois, mais paresseusement, ainsi que la cohérence dans la définition de Optional<T>(ie Optional<T>- Optional<T>opérateurs, ou même Supplier<Optional<T>>).

Vous pouvez essayer ceci:

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

Basé sur cette réponse

Que diriez-vous d'utiliser des fournisseurs lorsque vous voulez éviter d'évaluer une méthode coûteuse?

Comme ça:

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

Et puis en l'utilisant comme ceci:

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

Vous pouvez également utiliser des méthodes surchargées pour les appels avec deux, trois ou quatre arguments.

De plus, vous pouvez également utiliser des flux avec quelque chose comme ceci:

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

Que diriez-vous:

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

Java ArrayList autorise commodément les entrées nulles et cette expression est cohérente quel que soit le nombre d'objets à prendre en compte. (Sous cette forme, tous les objets considérés doivent être du même type.)

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