Java“?” ตัวดำเนินการสำหรับการตรวจสอบ null - มันคืออะไร? (ไม่ใช่ Ternary!)

ฉันกำลังอ่านบทความที่เชื่อมโยงจากเรื่อง slashdot และเจอเรื่องเล็กน้อยนี้:

ใช้ Java เวอร์ชันล่าสุดซึ่งพยายามทำให้การตรวจสอบตัวชี้ null ง่ายขึ้นโดยนำเสนอไวยากรณ์ชวเลขสำหรับการทดสอบตัวชี้ที่ไม่มีที่สิ้นสุด เพียงแค่เพิ่มเครื่องหมายคำถามลงในการเรียกแต่ละวิธีโดยอัตโนมัติจะรวมการทดสอบตัวชี้ค่าว่างโดยแทนที่รังของหนูของประโยคคำสั่ง if-then เช่น:

    public String getPostcode(Person person) {
      String ans= null;
      if (person != null) {
        Name nm= person.getName();
        if (nm!= null) {
          ans= nm.getPostcode();
        }
      }
      return ans
    } 

ด้วยสิ่งนี้:

public String getFirstName(Person person) {
      return person?.getName()?.getGivenName();
    } 

ฉันระบาดในอินเทอร์เน็ต (โอเคฉันใช้เวลาอย่างน้อย 15 นาทีในการใช้ googling รูปแบบต่างๆใน "java question mark") และไม่มีอะไรเลย ดังนั้นคำถามของฉัน: มีเอกสารอย่างเป็นทางการเกี่ยวกับเรื่องนี้หรือไม่? ฉันพบว่า C # มีตัวดำเนินการที่คล้ายกัน (ตัวดำเนินการ "??") แต่ฉันต้องการได้รับเอกสารสำหรับภาษาที่ฉันใช้งานอยู่หรือนี่เป็นเพียงการใช้ตัวดำเนินการด้านท้ายที่ฉัน ไม่เคยเห็นมาก่อน

ขอบคุณ!

แก้ไข: ลิงก์ไปยังบทความ: http://infoworld.com/d/developer-world/12-programming-mistakes-avoid-292

ความคิดดั้งเดิมมาจากความโกลาหล เสนอให้ Java 7 เป็นส่วนหนึ่งของ Project Coin: https://wiki.openjdk.java.net/display/Coin/2009+Proposals+TOC (Elvis and Other Null-Safe Operators) แต่ยังไม่ได้รับการยอมรับ .

ตัวดำเนินการเอลวิสที่เกี่ยวข้อง?: ถูกเสนอให้x ?: yจดชวเลขx != null ? x : yโดยเฉพาะเมื่อ x เป็นนิพจน์ที่ซับซ้อน

ไวยากรณ์นี้ไม่มีอยู่ใน Java และไม่มีกำหนดให้รวมอยู่ในเวอร์ชันที่กำลังจะมาถึงที่ฉันรู้จัก

มีข้อเสนอใน Java 7 แต่ถูกปฏิเสธ:

http://tech.puredanger.com/java7/#null

วิธีหนึ่งในการแก้ปัญหาการขาด "?" ตัวดำเนินการที่ใช้ Java 8 โดยไม่มีค่าใช้จ่ายในการ try-catch (ซึ่งอาจซ่อนNullPointerExceptionต้นกำเนิดจากที่อื่นตามที่กล่าวไว้ได้เช่นกัน) คือการสร้างคลาสเพื่อ "ไปป์" เมธอดในสไตล์ Java-8-Stream

public class Pipe<T> {
    private T object;

    private Pipe(T t) {
        object = t;
    }

    public static<T> Pipe<T> of(T t) {
        return new Pipe<>(t);
    }

    public <S> Pipe<S> after(Function<? super T, ? extends S> plumber) {
        return new Pipe<>(object == null ? null : plumber.apply(object));
    }

    public T get() {
        return object;
    }

    public T orElse(T other) {
        return object == null ? other : object;
    }
}

จากนั้นตัวอย่างที่กำหนดจะกลายเป็น:

public String getFirstName(Person person) {
    return Pipe.of(person).after(Person::getName).after(Name::getGivenName).get();
}

[แก้ไข]

เมื่อคิดต่อไปฉันพบว่าเป็นไปได้ที่จะบรรลุสิ่งเดียวกันโดยใช้คลาส Java 8 มาตรฐานเท่านั้น:

public String getFirstName(Person person) {
    return Optional.ofNullable(person).map(Person::getName).map(Name::getGivenName).orElse(null);
}

ในกรณีนี้มันเป็นไปได้ที่จะเลือกค่าเริ่มต้น (เช่น"<no first name>") แทนโดยผ่านเป็นพารามิเตอร์ของnullorElse

ดู: https://blogs.oracle.com/darcy/project-coin:-the-final-five-or-so (โดยเฉพาะ "Elvis และตัวดำเนินการที่ไม่ปลอดภัยอื่น ๆ ")

ผลลัพธ์คือคุณลักษณะนี้ได้รับการพิจารณาสำหรับ Java 7 แต่ไม่รวมอยู่ด้วย

ที่จริงผู้ประกอบการปลอดภัย dereference Groovy ของ คุณไม่สามารถใช้ใน Java ล้วน ๆ ได้ (น่าเศร้า) ดังนั้นโพสต์นั้นจึงไม่ถูกต้อง (หรืออาจทำให้เข้าใจผิดได้เล็กน้อยหากอ้างว่า Groovy เป็น "Java เวอร์ชันล่าสุด")

Java ไม่มีไวยากรณ์ที่แน่นอนแต่สำหรับ JDK-8 เรามีAPI เสริมพร้อมวิธีการต่างๆที่เราจำหน่าย ดังนั้นเวอร์ชัน C # ที่ใช้ตัวดำเนินการเงื่อนไขว่าง :

return person?.getName()?.getGivenName(); 

สามารถเขียนได้ดังต่อไปนี้ใน Java ด้วยOptional API :

 return Optional.ofNullable(person)
                .map(e -> e.getName())
                .map(e -> e.getGivenName())
                .orElse(null);

ถ้ามีของperson, getNameหรือgetGivenNameเป็นโมฆะแล้ว null จะถูกส่งกลับ

เป็นไปได้ที่จะกำหนดวิธีการใช้งานซึ่งแก้ปัญหานี้ได้ด้วย Java 8 lambda

นี่คือรูปแบบของการแก้ปัญหา H-MANsNullPointerExceptionแต่จะใช้วิธีการมากเกินไปกับการขัดแย้งหลายที่จะจัดการกับหลายขั้นตอนของการจับแทน

แม้ว่าฉันจะคิดว่าวิธีนี้เป็นวิธีที่ดี แต่ฉันคิดว่าฉันชอบวินาทีของ Helder Pereiraหนึ่งวินาทีเนื่องจากไม่ต้องใช้วิธีการใด ๆ

void example() {
    Entry entry = new Entry();
    // This is the same as H-MANs solution 
    Person person = getNullsafe(entry, e -> e.getPerson());    
    // Get object in several steps
    String givenName = getNullsafe(entry, e -> e.getPerson(), p -> p.getName(), n -> n.getGivenName());
    // Call void methods
    doNullsafe(entry, e -> e.getPerson(), p -> p.getName(), n -> n.nameIt());        
}

/** Return result of call to f1 with o1 if it is non-null, otherwise return null. */
public static <R, T1> R getNullsafe(T1 o1, Function<T1, R> f1) {
    if (o1 != null) return f1.apply(o1);
    return null; 
}

public static <R, T0, T1> R getNullsafe(T0 o0, Function<T0, T1> f1, Function<T1, R> f2) {
    return getNullsafe(getNullsafe(o0, f1), f2);
}

public static <R, T0, T1, T2> R getNullsafe(T0 o0, Function<T0, T1> f1, Function<T1, T2> f2, Function<T2, R> f3) {
    return getNullsafe(getNullsafe(o0, f1, f2), f3);
}


/** Call consumer f1 with o1 if it is non-null, otherwise do nothing. */
public static <T1> void doNullsafe(T1 o1, Consumer<T1> f1) {
    if (o1 != null) f1.accept(o1);
}

public static <T0, T1> void doNullsafe(T0 o0, Function<T0, T1> f1, Consumer<T1> f2) {
    doNullsafe(getNullsafe(o0, f1), f2);
}

public static <T0, T1, T2> void doNullsafe(T0 o0, Function<T0, T1> f1, Function<T1, T2> f2, Consumer<T2> f3) {
    doNullsafe(getNullsafe(o0, f1, f2), f3);
}


class Entry {
    Person getPerson() { return null; }
}

class Person {
    Name getName() { return null; }
}

class Name {
    void nameIt() {}
    String getGivenName() { return null; }
}

ฉันไม่แน่ใจว่ามันจะได้ผล ถ้าพูดว่าการอ้างอิงบุคคลเป็นโมฆะรันไทม์จะแทนที่ด้วยอะไร คนใหม่? นั่นจะต้องให้บุคคลนั้นมีการเริ่มต้นเริ่มต้นบางอย่างที่คุณคาดหวังในกรณีนี้ คุณอาจหลีกเลี่ยงข้อยกเว้นการอ้างอิงที่เป็นโมฆะ แต่คุณยังคงได้รับพฤติกรรมที่คาดเดาไม่ได้หากคุณไม่ได้วางแผนสำหรับการตั้งค่าประเภทนี้

ที่ ?? ตัวดำเนินการใน C # อาจเรียกว่าตัวดำเนินการ "coalesce" ได้ดีที่สุด คุณสามารถเชื่อมโยงหลายนิพจน์และจะส่งคืนนิพจน์แรกที่ไม่เป็นโมฆะ น่าเสียดายที่ Java ไม่มี ฉันคิดว่าสิ่งที่ดีที่สุดที่คุณทำได้คือใช้ตัวดำเนินการ ternary เพื่อทำการตรวจสอบค่าว่างและประเมินทางเลือกแทนนิพจน์ทั้งหมดหากสมาชิกใด ๆ ในห่วงโซ่เป็นโมฆะ:

return person == null ? "" 
    : person.getName() == null ? "" 
        : person.getName().getGivenName();

คุณยังสามารถใช้ try-catch:

try
{
   return person.getName().getGivenName();
}
catch(NullReferenceException)
{
   return "";
}

ที่นั่นคุณมีการเรียกใช้ null-safe ใน Java 8:

public void someMethod() {
    String userName = nullIfAbsent(new Order(), t -> t.getAccount().getUser()
        .getName());
}

static <T, R> R nullIfAbsent(T t, Function<T, R> funct) {
    try {
        return funct.apply(t);
    } catch (NullPointerException e) {
        return null;
    }
}

หากมีใครกำลังมองหาทางเลือกอื่นสำหรับเวอร์ชันจาวาคุณสามารถลองใช้สิ่งนี้ที่ฉันเขียน:

/**
 * Strong typed Lambda to return NULL or DEFAULT VALUES instead of runtime errors. 
 * if you override the defaultValue method, if the execution result was null it will be used in place
 * 
 * 
 * Sample:
 * 
 * It won't throw a NullPointerException but null.
 * <pre>
 * {@code
 *  new RuntimeExceptionHandlerLambda<String> () {
 *      @Override
 *      public String evaluate() {
 *          String x = null;
 *          return x.trim();
 *      }  
 *  }.get();
 * }
 * <pre>
 * 
 * 
 * @author Robson_Farias
 *
 */

public abstract class RuntimeExceptionHandlerLambda<T> {

    private T result;

    private RuntimeException exception;

    public abstract T evaluate();

    public RuntimeException getException() {
        return exception;
    }

    public boolean hasException() {
        return exception != null;
    }

    public T defaultValue() {
        return result;
    }

    public T get() {
        try {
            result = evaluate();
        } catch (RuntimeException runtimeException) {
            exception = runtimeException;
        }
        return result == null ? defaultValue() : result;
    }

}

คุณสามารถทดสอบโค้ดที่คุณให้มาและมันจะทำให้เกิดข้อผิดพลาดทางไวยากรณ์ดังนั้นจึงไม่รองรับใน Java Groovy รองรับและได้รับการเสนอสำหรับ Java 7 (แต่ไม่รวม)

อย่างไรก็ตามคุณสามารถใช้ตัวเลือกที่มีให้ใน Java 8 สิ่งนี้อาจช่วยคุณในการบรรลุบางสิ่งในบรรทัดที่คล้ายกัน https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html http://www.oracle.com/technetwork/articles/java/java8-optional-2175753.html

ตัวอย่างรหัสสำหรับตัวเลือก

เนื่องจาก Android ไม่รองรับ Lambda Functions เว้นแต่ว่าระบบปฏิบัติการที่คุณติดตั้งไว้คือ> = 24 เราจึงจำเป็นต้องใช้การสะท้อนกลับ

// Example using doIt function with sample classes
public void Test() {
    testEntry(new Entry(null));
    testEntry(new Entry(new Person(new Name("Bob"))));
}

static void testEntry(Entry entry) {
    doIt(doIt(doIt(entry,  "getPerson"), "getName"), "getName");
}

// Helper to safely execute function 
public static <T,R> R doIt(T obj, String methodName) {
    try {
       if (obj != null) 
           return (R)obj.getClass().getDeclaredMethod(methodName).invoke(obj);
    } catch (Exception ignore) {
    }
    return null;
}

// Sample test classes
    static class Entry {
        Person person;
        Entry(Person person) { this.person = person; }
        Person getPerson() { return person; }
    }

    static class Person {
        Name name;
        Person(Name name) { this.name = name; }
        Name getName() { return name; }
    }

    static class Name {
        String name;
        Name(String name) { this.name = name; }
        String getName() {
            System.out.print(" Name:" + name + " ");
            return name;
        }
    }
}

หากนี่ไม่ใช่ปัญหาด้านประสิทธิภาพสำหรับคุณคุณสามารถเขียนได้

public String getFirstName(Person person) {
  try {
     return person.getName().getGivenName();
  } catch (NullPointerException ignored) {
     return null;
  }
}