Java “?” Boş değeri kontrol etme operatörü - Nedir? (Üçlü değil!)

Bir slashdot hikayesinden bağlantılı bir makale okuyordum ve şu küçük haberle karşılaştım:

Sonsuz işaretçi testi için kısayol sözdizimi sunarak boş işaretçi denetimini kolaylaştırmaya çalışan en son Java sürümünü alın. Her yöntem çağrısına bir soru işareti eklemek, otomatik olarak boş işaretçiler için bir test içerir ve farenin if-then ifadeleri yuvasını değiştirir, örneğin:

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

Bununla:

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

İnterneti araştırdım (tamam, "java soru işareti" üzerinde en az 15 dakika googling varyasyonları harcadım) ve hiçbir şey alamadım. Öyleyse sorum: bununla ilgili herhangi bir resmi belge var mı? C # 'ın benzer bir operatörü ("??" operatörü) olduğunu buldum, ancak çalıştığım dil için dokümantasyonu almak istiyorum. Veya, bu sadece sahip olduğum üçlü operatörün bir kullanımı mı? daha önce hiç görülmemiş.

Teşekkürler!

DÜZENLEME: Makaleye bağlantı: http://infoworld.com/d/developer-world/12-programming-mistakes-avoid-292

Orijinal fikir, harika bir fikirden geliyor. Project Coin'in bir parçası olarak Java 7 için önerildi: https://wiki.openjdk.java.net/display/Coin/2009+Proposals+TOC (Elvis ve Diğer Null-Safe Operatörler), ancak henüz kabul edilmedi .

İlgili Elvis operatörü x ?: y?: İçin bir kısaltma yapması önerildi x != null ? x : y, özellikle x karmaşık bir ifade olduğunda kullanışlı.

Bu sözdizimi Java'da yoktur ve bildiğim gelecek sürümlerden herhangi birine dahil edilmesi planlanmamıştır.

Java 7'de bunun için bir öneri vardı, ancak reddedildi:

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

"?" Eksikliğini geçici olarak çözmenin bir yolu Try-catch ek yükü olmadan Java 8 kullanan operatör ( NullPointerExceptionbahsedildiği gibi, başka bir yerde ortaya çıkmış olanı da gizleyebilir ), Java-8-Stream stilinde yöntemleri "yönlendirmek" için bir sınıf oluşturmaktır.

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

Ardından, verilen örnek şöyle olur:

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

[DÜZENLE]

Daha fazla düşündükten sonra, aynı şeyi yalnızca standart Java 8 sınıflarını kullanarak elde etmenin aslında mümkün olduğunu anladım:

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

Bu durumda, parametresi olarak geçmek "<no first name>"yerine varsayılan bir değer (gibi ) seçmek bile mümkündür .nullorElse

Bakınız: https://blogs.oracle.com/darcy/project-coin:-the-final-five-or-so (özellikle "Elvis ve diğer boş güvenli operatörler").

Sonuç olarak, bu özellik Java 7 için düşünüldü, ancak dahil edilmedi.

Bu aslında Groovy'nin güvenli referans operatörü . Onu saf Java'da (ne yazık ki) kullanamazsınız, bu yüzden bu gönderi tamamen yanlıştır (veya Groovy'nin "Java'nın en son sürümü" olduğunu iddia ediyorsa, muhtemelen biraz yanıltıcıdır).

Java'nın tam sözdizimi yoktur, ancak JDK-8'den itibaren, çeşitli yöntemlerle isteğe bağlı API'ye sahibiz . Bu nedenle, boş koşullu operatörün kullanıldığı C # sürümü :

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

İsteğe Bağlı API ile Java'da aşağıdaki şekilde yazılabilir :

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

herhangi eğer person, getNameya getGivenNameboş sonra boş döndürülür edilir.

Java 8 lambda ile bunu oldukça güzel bir şekilde çözen util yöntemleri tanımlamak mümkündür.

Bu, H-MAN çözümünün bir varyasyonudur, ancak yakalamak yerine birden çok adımı işlemek için birden çok argümana sahip aşırı yüklenmiş yöntemler kullanır NullPointerException.

Bu çözümün harika olduğunu düşünsem bile Helder Pereira'nın ikinci saniyesini tercih ettiğimi düşünüyorum çünkü bu herhangi bir kullanım yöntemi gerektirmiyor.

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

Bunun işe yarayacağından bile emin değilim; diyelim ki kişi referansı boş olsaydı, çalışma zamanı onu neyle değiştirirdi? Yeni Kişi? Bu, Kişinin bu durumda bekleyeceğiniz bazı varsayılan başlatmaya sahip olmasını gerektirir. Boş referans istisnalarından kaçınabilirsiniz, ancak bu tür kurulumları planlamadıysanız yine de öngörülemeyen davranışlar elde edersiniz.

?? C # operatörü en iyi "birleştirme" operatörü olarak adlandırılabilir; birkaç ifadeyi zincirleyebilirsiniz ve boş olmayan ilk ifadeyi döndürür. Maalesef Java'da yok. Bence yapabileceğiniz en iyi şey, üç terimli operatörü kullanarak boş kontroller yapmak ve zincirdeki herhangi bir üye boş ise tüm ifadeye bir alternatifi değerlendirmek:

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

Ayrıca try-catch'i de kullanabilirsiniz:

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

İşte Java 8'de boş güvenlikli çağrı var:

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

Birisi eski java sürümleri için bir alternatif arıyorsanız, yazdığım şunu deneyebilirsiniz:

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

}

Verdiğiniz kodu test edebilirsiniz ve bu sözdizimi hatası verecektir, bu yüzden Java'da desteklenmemektedir. Groovy bunu destekliyor ve Java 7 için önerildi (ancak dahil edilmedi).

Bununla birlikte, Java 8'de sağlanan İsteğe Bağlı'yı kullanabilirsiniz. Bu, benzer bir hat üzerinde bir şey elde etmenize yardımcı olabilir. https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html http://www.oracle.com/technetwork/articles/java/java8-optional-2175753.html

İsteğe Bağlı Örnek Kod

Android, kurulu işletim sisteminiz> = 24 olmadığı sürece Lambda İşlevlerini desteklemediğinden, yansıma kullanmamız gerekir.

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

Bu sizin için bir performans sorunu değilse yazabilirsiniz

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