जावा "?" नल की जाँच के लिए ऑपरेटर - यह क्या है? (टर्नरी नहीं!)

Question 1

मैं एक स्लैशडॉट स्टोरी से जुड़ा एक लेख पढ़ रहा था, और इस छोटी सी ख़बर पर आया:

जावा का नवीनतम संस्करण लें, जो अंतहीन पॉइंटर परीक्षण के लिए शॉर्टहैंड सिंटैक्स की पेशकश करके नल-पॉइंटर चेकिंग को आसान बनाने की कोशिश करता है। प्रत्येक विधि के आह्वान पर एक प्रश्नवाचक चिह्न जोड़ने से स्वतः ही अशक्त बिंदुओं के लिए एक परीक्षण शामिल होता है, यदि तत्कालीन कथनों के चूहे के घोंसले की जगह, जैसे:
    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 मिनट की विविधताएं बिताईं) और कुछ भी नहीं मिला। तो, मेरा प्रश्न: क्या इस पर कोई आधिकारिक दस्तावेज है? मैंने पाया कि C # के पास एक समान ऑपरेटर ("??" ऑपरेटर) है, लेकिन मैं जिस भाषा में काम कर रहा हूं, उसके लिए दस्तावेज प्राप्त करना चाहता हूं। या, यह केवल उन सहायक ऑपरेटर का उपयोग है जो मैंने किया है। पहले कभी नहीं देखा।

धन्यवाद!

संपादित करें: लेख का लिंक: http://infoworld.com/d/developer-world/12-programming-mistakes-avoid-292

Question 2

मूल विचार ग्रूवी से आता है। यह प्रोजेक्ट कॉइन के भाग के रूप में जावा 7 के लिए प्रस्तावित किया गया था: https://wiki.openjdk.java.net/display/Coin/2009+Proposals+TOC (एल्विस और अन्य नल-सुरक्षित ऑपरेटर), लेकिन अभी तक स्वीकार नहीं किया गया है ।

संबंधित एल्विस ऑपरेटर ?: के लिए x ?: yशॉर्टहैंड बनाने का प्रस्ताव किया गया था x != null ? x : y, खासकर जब एक्स एक जटिल अभिव्यक्ति है।

Question 3

यह सिंटैक्स जावा में मौजूद नहीं है, और न ही यह किसी भी आगामी संस्करण में शामिल किए जाने के लिए स्लेटेड है जो मुझे पता है।

Question 4

जावा 7 में इसके लिए एक प्रस्ताव था, लेकिन इसे अस्वीकार कर दिया गया था:

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

Question 5

की कमी को हल करने का एक तरीका "?" प्रयास-कैच के ओवरहेड के बिना जावा 8 का उपयोग करने वाला ऑपरेटर (जो कि एक NullPointerExceptionउत्पत्ति को कहीं और छिपा सकता है, जैसा कि उल्लेख किया गया है) जावा-8-स्ट्रीम शैली में "पाइप" विधियों के लिए एक वर्ग बनाने के लिए है।

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

[संपादित करें]

आगे सोचने पर, मुझे पता चला कि वास्तव में केवल मानक जावा 8 कक्षाओं का उपयोग करके ही इसे प्राप्त करना संभव है:

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

इस मामले में, पैरामीटर के रूप में इसे पारित "<no first name>"करने के बजाय डिफ़ॉल्ट मान (जैसे ) चुनना संभव nullहै orElse।

Question 6

देखें: https://blogs.oracle.com/darcy/project-coin:-the-final-five-or-so (विशेष रूप से "एल्विस और अन्य अशक्त सुरक्षित ऑपरेटर")।

परिणाम यह है कि इस सुविधा को जावा 7 के लिए माना जाता था, लेकिन इसमें शामिल नहीं किया गया था।

Question 7

यह वास्तव में ग्रूवी के सुरक्षित-प्रसार ऑपरेटर है । आप इसे शुद्ध जावा (उदासी से) में उपयोग नहीं कर सकते हैं, इसलिए यह पोस्ट केवल गलत है (या अधिक संभावना थोड़ा भ्रामक है, अगर यह ग्रूवी को "जावा का नवीनतम संस्करण" होने का दावा कर रहा है)।

Question 8

जावा में सटीक सिंटैक्स नहीं है लेकिन JDK-8 के रूप में, हमारे पास हमारे निपटान में विभिन्न तरीकों के साथ वैकल्पिक एपीआई है । तो, नल सशर्त ऑपरेटर के उपयोग के साथ C # संस्करण :

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

वैकल्पिक एपीआई के साथ जावा में निम्नानुसार लिखा जा सकता है :

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

यदि कोई है person, getNameया getGivenNameअशक्त है तो अशक्त वापस आ गया है।

Question 9

उपयोग विधियों को परिभाषित करना संभव है जो जावा 8 लैम्ब्डा के साथ लगभग सुंदर तरीके से इसे हल करता है।

यह H-MAN समाधान की एक भिन्नता है, लेकिन यह कई तर्कों के साथ अतिभारित तरीकों का उपयोग करता है, पकड़ने के बजाय कई चरणों को संभालने के लिए NullPointerException।

यहां तक कि अगर मुझे लगता है कि यह समाधान एक तरह से अच्छा है, तो मुझे लगता है कि मैं हेल्डर परेरा के सेकंड को पसंद करता हूं क्योंकि इसके लिए किसी भी तरीके की आवश्यकता नहीं है।

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

Question 10

मुझे यकीन नहीं है कि यह भी काम करेगा; यदि, कहते हैं, व्यक्ति संदर्भ शून्य था, तो रनटाइम इसकी जगह क्या लेगा? एक नया व्यक्ति? इसके लिए व्यक्ति को कुछ डिफ़ॉल्ट इनिशियलाइज़ेशन की आवश्यकता होगी जो आप इस मामले में चाहते हैं। यदि आप इन प्रकार के सेटअपों की योजना नहीं बनाते हैं, तो आप अशक्त संदर्भ अपवादों से बच सकते हैं लेकिन फिर भी आपको अप्रत्याशित व्यवहार नहीं मिलेगा।

?? सी # में ऑपरेटर को "कोलेसस" ऑपरेटर कहा जा सकता है; आप कई भावों को श्रृंखलाबद्ध कर सकते हैं और यह सबसे पहले वापस आएगा जो शून्य नहीं है। दुर्भाग्य से, जावा में यह नहीं है। मुझे लगता है कि आप जो सबसे अच्छा कर सकते हैं, वह टर्नरी ऑपरेटर का उपयोग अशक्त जाँच करने के लिए और संपूर्ण अभिव्यक्ति के विकल्प का मूल्यांकन करने के लिए है यदि श्रृंखला में कोई भी सदस्य अशक्त है:

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

आप भी कोशिश पकड़ सकते हैं:

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

Question 11

आपके पास यह है, जावा 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;
    }
}

Question 12

अगर कोई पुराने जावा संस्करणों के लिए एक विकल्प की तलाश कर रहा है, तो आप यह एक कोशिश कर सकते हैं जो मैंने लिखा था:

/**
 * 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;
    }

}

Question 13

आप अपने द्वारा प्रदान किए गए कोड का परीक्षण कर सकते हैं और यह सिंटैक्स त्रुटि देगा। तो, यह जावा में समर्थित नहीं है। ग्रूवी इसका समर्थन करता है और इसे जावा 7 के लिए प्रस्तावित किया गया था (लेकिन कभी शामिल नहीं किया गया)।

हालाँकि, आप जावा 8 में दिए गए वैकल्पिक का उपयोग कर सकते हैं। यह आपको इसी तरह की रेखा पर कुछ हासिल करने में मदद कर सकता है। https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html http://www.oracle.com/technetwork/articles/java/java8-optional-2175753.html

वैकल्पिक के लिए उदाहरण कोड

Question 14

चूंकि एंड्रॉइड लैम्बडा फंक्शंस का समर्थन नहीं करता है जब तक कि आपका स्थापित ओएस> = 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;
        }
    }
}

Question 15

यदि यह आपके लिए प्रदर्शन का मुद्दा नहीं है, तो आप लिख सकते हैं

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