Java ist übersät mit Anweisungen wie:

if(cage.getChicken() != null) {
    dinner = cage.getChicken();
} else {
    dinner = getFreeRangeChicken();
}

Wozu zwei Anrufe nötig sind getChicken() bevor das zurückgegebene Objekt zugewiesen werden kann dinner.

Dies könnte auch so in einer Zeile geschrieben werden:

dinner = cage.getChicken() != null? cage.getChicken() : getFreeRangeChicken();

Aber leider kommen noch zwei Anrufe dazu getChicken().

Natürlich könnten wir eine lokale Variable zuweisen und dann den ternären Operator erneut verwenden, um sie zuzuweisen, wenn sie nicht null ist, aber das sind zwei Zeilen und nicht so hübsch:

FutureMeal chicken = cage.getChicken();
dinner = chicken != null? chicken : getFreeRangeChicken();

Also gibt es eine Möglichkeit zu sagen:

Variable var = ein Wert, wenn ein Wert nicht null ist ODER ein anderer Wert;

Und ich schätze, ich spreche hier nur von Syntax, nachdem der Code kompiliert ist, macht es wahrscheinlich keinen großen Unterschied, wie der Code in Bezug auf die Leistung geschrieben wurde.

Da dies ein so allgemeiner Code ist, wäre es großartig, einen Einzeiler zu haben, um ihn zu schreiben.

Haben andere Sprachen diese Funktion?

Gleiches Prinzip wie Lokis Antwort, aber kürzer. Denken Sie nur daran, dass kürzer nicht automatisch besser bedeutet.

dinner = Optional.ofNullable(cage.getChicken())
  .orElse(getFreerangeChicken());

Hinweis: Diese Verwendung von Optional wird ausdrücklich von den Architekten des JDK und den Designern des optionalen Features abgeraten. Sie weisen jedes Mal ein frisches Objekt zu und werfen es sofort weg. Aber auf der anderen Seite kann es durchaus lesbar sein.

Java fehlt der Coalesce-Operator, daher ist Ihr Code mit einem expliziten Temporär Ihre beste Wahl für eine Zuweisung mit einem einzigen Aufruf.

Sie können die Ergebnisvariable wie folgt als temporäre verwenden:

dinner = ((dinner = cage.getChicken()) != null) ? dinner : getFreeRangeChicken();

Dies ist jedoch schwer zu lesen.

Seit Java 9 haben Sie Objekte#requireNonNullElse was macht:

public static <T> T requireNonNullElse(T obj, T defaultObj) {
    return (obj != null) ? obj : requireNonNull(defaultObj, "defaultObj");
}

Ihr Code wäre

dinner = Objects.requireNonNullElse(cage.getChicken(), getFreeRangeChicken());

Das ist 1 Leitung und Anrufe getChicken() nur einmal, so dass beide Anforderungen erfüllt sind.

Beachten Sie, dass das zweite Argument nicht sein kann null auch; Diese Methode erzwingt Nicht-Nullheit des zurückgegebenen Werts.

Betrachten Sie auch die Alternative Objekte#requireNonNullElseGet:

public static <T> T requireNonNullElseGet(T obj, Supplier<? extends T> supplier)

was das zweite Argument nicht einmal auswertet, wenn das erste es nicht ist nullhat aber den Aufwand, eine zu erstellen Supplier.

Wenn Sie noch nicht auf Java 1.8 sind und es Ihnen nichts ausmacht, commons-lang zu verwenden, können Sie es verwenden org.apache.commons.lang3.ObjectUtils#defaultIfNull

Dein Code wäre:

dinner = ObjectUtils.defaultIfNull(cage.getChicken(),getFreeRangeChicken())

Mit Java 1.8 können Sie verwenden Optional

public class Main  {

    public static void main(String[] args) {

        //example call, the methods are just dumb templates, note they are static
        FutureMeal meal = getChicken().orElse(getFreeRangeChicken());

        //another possible way to call this having static methods is
        FutureMeal meal = getChicken().orElseGet(Main::getFreeRangeChicken); //method reference

        //or if you would use a Instance of Main and call getChicken and getFreeRangeChicken
        // as nonstatic methods (assume static would be replaced with public for this)
        Main m = new Main();
        FutureMeal meal = m.getChicken().orElseGet(m::getFreeRangeChicken); //method reference

        //or
        FutureMeal meal = m.getChicken().orElse(m.getFreeRangeChicken()); //method call


    }

    static Optional<FutureMeal> getChicken(){

        //instead of returning null, you would return Optional.empty() 
        //here I just return it to demonstrate
        return Optional.empty();

        //if you would return a valid object the following comment would be the code
        //FutureMeal ret = new FutureMeal(); //your return object
        //return Optional.of(ret);            

    }

    static FutureMeal getFreeRangeChicken(){
        return new FutureMeal();
    }
}

Sie würden eine Logik für implementieren getChicken entweder zurückgeben Optional.empty() statt null, oder Optional.of(myReturnObject)wo myReturnObject ist dein chicken.

Dann kannst du anrufen getChicken() und ob es zurückkommen würde Optional.empty() das orElse(fallback) würde Ihnen geben, was auch immer der Fallback wäre, in Ihrem Fall die zweite Methode.

Verwenden Sie Ihre eigenen

public static <T> T defaultWhenNull(@Nullable T object, @NonNull T def) {
    return (object == null) ? def : object;
}

Beispiel:

defaultWhenNull(getNullableString(), "");

Vorteile

• Funktioniert, wenn Sie nicht in Java8 entwickeln
• Funktioniert für die Android-Entwicklung mit Unterstützung für vor API 24 Geräte
• Benötigt keine externe Bibliothek

Nachteile

• Wertet immer die aus default value (im Gegensatz zu cond ? nonNull() : notEvaluated())

  Dies könnte umgangen werden, indem ein Callable anstelle eines Standardwerts übergeben wird, was es jedoch etwas komplizierter und weniger dynamisch macht (z. B. wenn die Leistung ein Problem ist).

  Auf den gleichen Nachteil stößt man übrigens bei der Nutzung Optional.orElse() 😉

dinner = cage.getChicken();
if(dinner == null) dinner = getFreeRangeChicken();

oder

if( (dinner = cage.getChicken() ) == null) dinner = getFreeRangeChicken();