Java에서 null이 아닌 첫 번째 값을 얻는 방법은 무엇입니까?

Java와 동등한 SQL이 있습니까? COALESCE 기능이 있습니까? 즉, 여러 변수의 첫 번째 null이 아닌 값을 반환하는 방법이 있습니까?

예 :

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

어떻게 든의 첫 번째 null이 아닌 값을 반환하는 문을 갖고 싶어 a, b그리고 c-이 경우, 반환 b, 또는 4.4. (sql 메소드와 같은 것-return 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 ...
}

아파치 커먼즈 랭 3

ObjectUtils.firstNonNull(T...)

자바 8 스트림

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

확인할 두 개의 변수 만 있고 구아바를 사용하는 경우 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 선택적을 가져 오는 경우 표현식이 나쁘지 않습니다.

불행히도 "여러 변수"의 경우는 선택적 방법으로는 불가능합니다. 대신 다음을 사용할 수 있습니다.

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

바이트 코드로 컴파일하기 전에이 "coalesce function"의 사용법을 찾고이를 다음과 같은 구성으로 대체하는 전처리 기가 있어야합니다.

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

2014-09-02 업데이트 :

Java 8 및 Lambdas 덕분에 Java에서 진정한 통합이 가능할 수 있습니다! 중요한 기능 포함 : 특정 표현식은 필요할 때만 평가됩니다. 이전 표현식이 널이 아닌 경우 다음 표현식은 평가되지 않습니다 (메소드가 호출되지 않거나 계산 또는 디스크 / 네트워크 조작이 수행되지 않음).

Java 8 에 대한 기사를 작성했습니다 – 통합 – hledáme neNULLové hodnoty – (체코 어로 작성되었지만 모든 사람들이 코드 예제를 이해할 수 있기를 바랍니다).

구아바로 할 수있는 일 :

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

NPE가 발생하면 모두하지 않는 a하고 b있습니다null .

편집 : 나는 틀렸다, 그것은 NPE를 던진다. Michal Čizmazia 가 논평 한 올바른 방법 은 다음과 같습니다.

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()effectiveAgeSupplier<Integer>

IMHO, 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;
}