วิธีรับค่าที่ไม่ใช่ค่าแรกใน Java

มีCOALESCEฟังก์ชันJava เทียบเท่ากับ Java หรือไม่? นั่นคือมีวิธีใดที่จะส่งกลับค่าที่ไม่ใช่ศูนย์แรกของตัวแปรหลายตัวหรือไม่?

เช่น

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

Apache Commons Lang 3

ObjectUtils.firstNonNull(T...)

Java 8 Stream

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

หากมีเพียงสองตัวแปรที่จะตรวจสอบและคุณกำลังใช้ฝรั่งคุณสามารถใช้MoreObjects.firstNonNull (T แรก T วินาที)

หากมีเพียงสองการอ้างอิงเพื่อทดสอบและคุณใช้ Java 8 คุณสามารถใช้

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

หากคุณนำเข้าแบบคงที่ตัวเลือกการแสดงออกไม่ได้เลวร้ายเกินไป

น่าเสียดายที่กรณีของคุณที่มี "ตัวแปรหลายตัว" ไม่สามารถทำได้ด้วยวิธีการที่เป็นตัวเลือก คุณสามารถใช้:

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

สถานการณ์นี้เรียกร้องให้พรีโปรเซสเซอร์บางตัว เพราะถ้าคุณเขียนฟังก์ชั่น (วิธีการคงที่) ซึ่งเลือกค่าแรกไม่ใช่ค่า null มันประเมินรายการทั้งหมด เป็นปัญหาหากบางรายการเป็นการเรียกใช้เมธอด (อาจเป็นการเรียกใช้เมธอดที่แพง) และวิธีการนี้เรียกว่าแม้ว่ารายการใด ๆ ก่อนหน้าพวกเขาจะไม่เป็นโมฆะ

ฟังก์ชั่นบางอย่างเช่นนี้

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

ควรใช้ แต่ก่อนที่จะรวบรวมเป็นรหัส byte ควรมี preprocessor ซึ่งค้นหาการใช้งานของ„ coalesce function“ นี้และแทนที่มันด้วยการสร้างเช่น

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

อัปเดต 2014-09-02:

ขอบคุณ Java 8 และ Lambdas มีความเป็นไปได้ที่จะมีการรวมตัวกันอย่างแท้จริงใน Java! รวมถึงคุณสมบัติที่สำคัญ: นิพจน์เฉพาะจะได้รับการประเมินเมื่อจำเป็นเท่านั้น - หากนิพจน์ก่อนหน้านี้ไม่เป็นโมฆะจะไม่มีการประเมินผลต่อไปนี้ (ไม่มีการเรียกใช้เมธอด

ฉันเขียนบทความเกี่ยวกับเรื่องนี้Java 8: coalesce - hledámeneNULLové hodnoty - (เขียนเป็นภาษาเช็ก แต่ฉันหวังว่าตัวอย่างโค้ดจะเข้าใจได้สำหรับทุกคน)

ด้วย Guava คุณสามารถทำได้:

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

ซึ่งไม่เคยโยน NPE ถ้าทั้งสองaและมีbnull

แก้ไข: ฉันผิดมันโยน 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()หรือเพียงแค่effectiveAgeถ้าเรามีความสุขกับSupplier<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 ช่วยให้รายการ null เป็นไปอย่างสะดวกและการแสดงออกนี้สอดคล้องกันโดยไม่คำนึงถึงจำนวนวัตถุที่ต้องพิจารณา (ในรูปแบบนี้วัตถุทั้งหมดที่พิจารณาจะต้องเป็นประเภทเดียวกัน)

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