Làm thế nào để có được giá trị khác null đầu tiên trong Java?

Có một hàm Java tương đương với hàm của SQL COALESCEkhông? Đó là, có cách nào để trả về giá trị không null đầu tiên của một số biến không?

ví dụ

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

Tôi muốn bằng cách nào đó có một tuyên bố rằng sẽ trả về giá trị null không đầu a, bvà c- trong trường hợp này, nó sẽ quay trở lại b, hoặc 4.4. (Một cái gì đó giống như phương pháp sql - return COALESCE(a,b,c)). Tôi biết rằng tôi có thể làm điều đó một cách rõ ràng với một cái gì đó như:

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

Nhưng tôi tự hỏi nếu có bất kỳ chức năng tích hợp, được chấp nhận để thực hiện điều này.

Không, không có.

Gần nhất bạn có thể nhận được là:

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

Vì lý do hiệu quả, bạn có thể xử lý các trường hợp phổ biến như sau:

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

Commons Lang 3

ObjectUtils.firstNonNull(T...)

Luồng Java 8

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

Nếu chỉ có hai biến để kiểm tra và bạn đang sử dụng Guava, bạn có thể sử dụng MoreObjects.firstNonNull (T đầu tiên, T giây) .

Nếu chỉ có hai tham chiếu để kiểm tra và bạn đang sử dụng Java 8, bạn có thể sử dụng

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

Nếu bạn nhập tĩnh Tùy chọn, biểu thức không quá tệ.

Thật không may, trường hợp của bạn với "một số biến" là không thể với phương thức Tùy chọn. Thay vào đó bạn có thể sử dụng:

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

Theo câu trả lời của LES2, bạn có thể loại bỏ một số sự lặp lại trong phiên bản hiệu quả, bằng cách gọi hàm quá tải:

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

Tình huống này đòi hỏi một số tiền xử lý. Bởi vì nếu bạn viết một hàm (phương thức tĩnh) chọn giá trị không null đầu tiên, nó sẽ đánh giá tất cả các mục. Đó là vấn đề nếu một số mục là các cuộc gọi phương thức (có thể là các cuộc gọi phương thức tốn kém thời gian). Và phương thức này được gọi ngay cả khi bất kỳ mục nào trước chúng không phải là null.

Một số chức năng như thế này

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

nên được sử dụng nhưng trước khi biên dịch thành mã byte nên có một bộ tiền xử lý tìm các cách sử dụng hàm „kết hợp này và thay thế nó bằng cách xây dựng như

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

Cập nhật 2014-09 / 02:

Nhờ có Java 8 và Lambdas, có khả năng có sự kết hợp thực sự trong Java! Bao gồm tính năng quan trọng: các biểu thức cụ thể chỉ được ước tính khi cần - nếu trước đó không phải là null, thì các biểu thức sau không được đánh giá (các phương thức không được gọi, tính toán hoặc hoạt động của đĩa / mạng không được thực hiện).

Tôi đã viết một bài viết về nó Java 8: coalesce - hledáme neNULLové hodnoty - (viết bằng tiếng Séc, nhưng tôi hy vọng rằng các ví dụ mã có thể hiểu được cho mọi người).

Với ổi bạn có thể làm:

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

mà không ném NPE nếu cả hai avà bđược null.

EDIT: Tôi đã sai, nó ném NPE. Cách chính xác như nhận xét của Michal izmazia là:

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

Chỉ để hoàn thiện, trường hợp "một vài biến" thực sự có thể, mặc dù không thanh lịch chút nào. Ví dụ, đối với các biến o, pvà q:

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

Xin lưu ý việc sử dụng các orElseGet()tham dự vào các trường hợp đó o, pvàq không biến nhưng biểu thức hoặc đắt tiền hoặc với mong muốn tác dụng phụ.

Trong trường hợp chung nhất 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

Điều này có thể tạo ra các biểu thức quá dài. Tuy nhiên, nếu chúng ta đang cố gắng di chuyển đến một thế giới mà không có null, thì v[i]có lẽ hầu hết đã thuộc loại Optional<String>, trái ngược với đơn giản String. Trong trường hợp này,

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

hoặc trong trường hợp biểu thức:

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

Hơn nữa, nếu bạn cũng đang di chuyển đến một phong cách chức năng-declarative, o, p, và qnên loại Supplier<String>như trong:

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

Và sau đó toàn bộ coalescegiảm đơn giản để o.get().

Đối với một ví dụ cụ thể hơn:

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()và ageFromInput()sẽ trở lại Optional<Integer>, một cách tự nhiên.

Và sau đó coalescetrở thành effectiveAge.get()hoặc đơn giản effectiveAgenếu chúng ta hài lòng với a Supplier<Integer>.

IMHO, với Java 8, chúng ta sẽ thấy ngày càng nhiều mã được cấu trúc như thế này, vì nó cực kỳ tự giải thích và hiệu quả cùng một lúc, đặc biệt là trong các trường hợp phức tạp hơn.

Tôi nhớ một lớp Lazy<T>chỉ gọi một lần Supplier<T>duy nhất, nhưng uể oải, cũng như sự nhất quán trong định nghĩa của Optional<T>(tức là Optional<T>- Optional<T>toán tử, hoặc thậm chí Supplier<Optional<T>>).

Bạn có thể thử điều này:

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

Dựa trên phản hồi này

Làm thế nào về việc sử dụng các nhà cung cấp khi bạn muốn tránh đánh giá một số phương pháp đắt tiền?

Như thế này:

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

Và sau đó sử dụng nó như thế này:

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

Bạn cũng có thể sử dụng các phương thức quá tải cho các cuộc gọi với hai, ba hoặc bốn đối số.

Ngoài ra, bạn cũng có thể sử dụng các luồng với nội dung như sau:

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

Làm thế nào về:

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

Java ArrayList thuận tiện cho phép các mục nhập null và biểu thức này phù hợp bất kể số lượng đối tượng được xem xét. (Trong mẫu này, tất cả các đối tượng được coi là cần phải cùng loại.)

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