Java"?"Operator do sprawdzania null - Co to jest? (Nie Ternary!)

Ta składnia nie istnieje w Javie, ani nie ma być dołączona do żadnej z nadchodzących wersji, o których wiem.

W Javie 7 pojawiła się propozycja, ale została odrzucona:

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

Jeden sposób na obejście braku"?"operatorem używającym Javy 8 bez narzutu try-catch (który mógłby również ukryć NullPointerException pochodzące z innego miejsca, jak wspomniano) jest stworzenie klasy do" rurowania " metod w stylu 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;
    }
}

Wtedy podany przykład będzie:

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

[EDIT]

Po zastanowieniu się, doszedłem do wniosku, że możliwe jest osiągnięcie tego samego tylko przy użyciu standardowych klas Java 8:

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

W tym przypadku, można nawet wybrać wartość domyślną (np. "<no first name>") zamiast null, przekazując ją jako parametr orElse.

Zobacz: https://blogs.oracle.com/darcy/project-coin:-the-final-five-or-so (w szczególności "Elvis and other null safe operators").

Wynik jest taki, że ta funkcja była brana pod uwagę w Javie 7, ale nie została uwzględniona.

To właściwie Operator bezpiecznej dereferencji Groovy ' ego . Nie można go używać w czystej Javie (niestety), więc ten post jest po prostu błędny (lub raczej nieco mylący, jeśli twierdzi, że Groovy to "najnowsza wersja Javy").

Możliwe jest zdefiniowanie metod util, które rozwiązują to w prawie ładny sposób za pomocą Java 8 lambda.

Jest to odmiana rozwiązania H-MANs , ale używa przeciążonych metod z wieloma argumentami do obsługi wielu kroków zamiast przechwytywania NullPointerException.

Nawet jeśli myślę, że to rozwiązanie jest fajne, myślę, że wolę Helder Pereira ' s seconds one, ponieważ nie wymaga to żadnych metod util.

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

Nie jestem pewien, czy to w ogóle zadziała; jeśli, powiedzmy, Referencja do osoby była null, co by ją zastąpiło przez runtime? Nowa osoba? Wymagałoby to od tej osoby domyślnej inicjalizacji, której można by się spodziewać w tym przypadku. Możesz unikać WYJĄTKÓW null reference, ale nadal zachowywałbyś się nieprzewidywalnie, gdybyś nie planował tego typu konfiguracji.

The ?? operator w C# może być najlepiej określany operatorem "coalesce"; można łańcuchować kilka wyrażeń i zwróci po pierwsze, to nie jest null. Niestety Java tego nie ma. Myślę, że najlepsze co możesz zrobić, to użyć operatora trójdzielnego do wykonania kontroli null i oceny alternatywy dla całego wyrażenia, jeśli jakikolwiek element w łańcuchu jest null:

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

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

Tutaj masz, null-bezpieczne wywołanie w Javie 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;
    }
}

Jeśli ktoś szuka alternatywy dla starych wersji Javy, może spróbować tej, którą napisałem:

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

}

Możesz przetestować kod, który podałeś i poda składnię error.So, nie jest obsługiwana w Javie. Groovy nie obsługuje go i został zaproponowany dla Java 7 (ale nigdy nie został uwzględniony).

Można jednak użyć opcjonalnej wersji Java 8. Może to pomóc w osiągnięciu czegoś podobnego Kolejka https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html http://www.oracle.com/technetwork/articles/java/java8-optional-2175753.html

Przykładowy kod dla opcjonalnego

Java nie posiada dokładnej składni , ale od JDK-8 mamy opcjonalne API z różnymi metodami do dyspozycji. Tak więc, Wersja C# z użyciem null operator warunkowy :

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

Można zapisać w Javie w następujący sposób za pomocą opcjonalnego API :

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

Jeśli którykolwiek z person, getName or getGivenName is null then null is returned.

Jeśli nie jest to dla Ciebie problem z wydajnością, możesz napisać

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