Как получить первое ненулевое значение в Java?

Есть ли Java-эквивалент функции SQL COALESCE? То есть есть ли способ вернуть первое ненулевое значение нескольких переменных?

например

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

Я хочу , чтобы как - то заявление , которое будет возвращать первое значение ненулевого из a, bи c- в этом случае было бы вернуться b, или 4,4. (Что-то вроде метода sql - возврат COALESCE(a,b,c)). Я знаю, что могу сделать это явно с помощью чего-то вроде:

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

Но мне было интересно, есть ли какая-нибудь встроенная, принятая функция для достижения этой цели.

Нет, нет

Самое близкое, что вы можете получить:

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

По эффективным причинам вы можете справиться с общими случаями следующим образом:

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)

Если нужно проверить только две переменные и вы используете Guava, вы можете использовать MoreObjects.firstNonNull (T first, T second) .

Если есть только две ссылки для тестирования, и вы используете Java 8, вы можете использовать

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

Если вы импортируете static Optional, выражение не так уж плохо.

К сожалению, ваш случай с «несколькими переменными» невозможен при использовании Optional-метода. Вместо этого вы можете использовать:

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

Следуя ответу LES2, вы можете устранить некоторые повторения в эффективной версии, вызвав перегруженную функцию:

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

Эта ситуация требует некоторого препроцессора. Потому что, если вы напишите функцию (статический метод), которая выбирает первое ненулевое значение, она оценивает все элементы. Это проблема, если некоторые элементы являются вызовами методов (могут быть дорогостоящие вызовы методов). И эти методы вызываются, даже если любой элемент перед ними не равен нулю.

Некоторые функции, подобные этой

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

должен использоваться, но перед компиляцией в байт-код должен быть препроцессор, который находит использование этой «функции объединения» и заменяет ее конструкцией, подобной

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

Обновление 2014-09-02:

Благодаря Java 8 и Lambdas появилась возможность объединиться в Java! Включая критическую особенность: определенные выражения оцениваются только при необходимости - если ранее одно из них не является нулевым, то следующие не оцениваются (методы не вызываются, вычисления или операции с диском / сетью не выполняются).

Я написал статью об этом Java 8: coalesce - hledáme neNULLové hodnoty - (написано на чешском языке, но я надеюсь, что примеры кода понятны для всех).

С Guava вы можете сделать:

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

который не бросает NPE, если оба aи bесть null.

РЕДАКТИРОВАТЬ: я был неправ, он бросает NPE. Правильный путь, который прокомментировал Михал Чизмия, таков :

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

Просто для полноты, случай «нескольких переменных» действительно возможен, хотя и вовсе не элегантен. Например, для переменных o, pи q:

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

Пожалуйста, обратите внимание на orElseGet()то o, что использование , pи qне являются переменными, а выражениями, дорогими или с нежелательными побочными эффектами.

В самом общем случае 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

Это может генерировать выражения чрезмерно долго. Однако, если мы пытаемся перейти в мир без null, то v[i], скорее всего, это уже тип Optional<String>, а не просто String. В таком случае,

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

или в случае выражений:

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

Кроме того, если вы также переход к функционально-декларативному стилю o, pи qдолжно быть типа , Supplier<String>как в:

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

И тогда все coalesceсводится просто к o.get().

Для более конкретного примера:

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()И ageFromInput()было бы уже вернуться Optional<Integer>, естественно.

И тогда coalesceстановится effectiveAge.get()или просто effectiveAgeесли мы довольны собой Supplier<Integer>.

ИМХО, с Java 8 мы увидим все больше и больше такого структурированного кода, поскольку он чрезвычайно понятен и эффективен одновременно, особенно в более сложных случаях.

Я действительно пропускаю класс, Lazy<T>который вызывает Supplier<T>только один раз, но лениво, а также последовательность в определении Optional<T>(то есть Optional<T>- Optional<T>операторы или даже Supplier<Optional<T>>).

Вы можете попробовать это:

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

На основании этого ответа

Как насчет использования поставщиков, если вы хотите избежать оценки какого-либо дорогостоящего метода?

Как это:

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

И затем использовать это так:

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

Вы также можете использовать перегруженные методы для вызовов с двумя, тремя или четырьмя аргументами.

Кроме того, вы также можете использовать потоки с чем-то вроде этого:

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

Как насчет:

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

Java ArrayList удобно допускает нулевые записи, и это выражение является согласованным независимо от количества рассматриваемых объектов. (В этой форме все рассматриваемые объекты должны быть одного типа.)

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