Warum sollte Optional in Java 8+ anstelle von herkömmlichen Nullzeigerprüfungen verwendet werden?

Wir sind kürzlich zu Java 8 übergegangen. Jetzt sehe ich Anwendungen, die mit OptionalObjekten überflutet sind.

Vor Java 8 (Style 1)

Employee employee = employeeServive.getEmployee();

if(employee!=null){
    System.out.println(employee.getId());
}

Nach Java 8 (Style 2)

Optional<Employee> employeeOptional = Optional.ofNullable(employeeService.getEmployee());
if(employeeOptional.isPresent()){
    Employee employee = employeeOptional.get();
    System.out.println(employee.getId());
}

Ich sehe keinen Mehrwert, Optional<Employee> employeeOptional = employeeService.getEmployee();wenn der Dienst selbst optional zurückgibt:

Ich komme aus Java 6 und sehe Stil 1 klarer und mit weniger Codezeilen. Gibt es einen wirklichen Vorteil, den ich hier vermisse?

Konsolidiert aus dem Verständnis aller Antworten und weiteren Recherchen im Blog

Style 2 ist für Java 8 nicht ausreichend, um den vollen Nutzen zu erzielen. Du willst das if ... useüberhaupt nicht. Siehe Oracle Beispiele . Wenn wir ihren Rat befolgen, bekommen wir:

Stil 3

// Changed EmployeeServive to return an optional, no more nulls!
Optional<Employee> employee = employeeServive.getEmployee();
employee.ifPresent(e -> System.out.println(e.getId()));

Oder ein längerer Ausschnitt

Optional<Employee> employee = employeeServive.getEmployee();
// Sometimes an Employee has forgotten to write an up-to-date timesheet
Optional<Timesheet> timesheet = employee.flatMap(Employee::askForCurrentTimesheet); 
// We don't want to do the heavyweight action of creating a new estimate if it will just be discarded
client.bill(timesheet.orElseGet(EstimatedTimesheet::new));

Wenn Sie Optionalals "Kompatibilitätsebene" eine ältere API verwenden, die möglicherweise noch zurückgegeben wird null, kann es hilfreich sein, die Option (nicht leer) zu erstellen, wenn Sie sich sicher sind , dass Sie über etwas verfügen. ZB wo du geschrieben hast:

Optional<Employee> employeeOptional = Optional.ofNullable(employeeService.getEmployee());
if(employeeOptional.isPresent()){
    Employee employeeOptional= employeeOptional.get();
    System.out.println(employee.getId());
}

Ich würde mich entscheiden für:

Optional.of(employeeService)                 // definitely have the service
        .map(EmployeeService::getEmployee)   // getEmployee() might return null
        .map(Employee::getId)                // get ID from employee if there is one
        .ifPresent(System.out::println);     // and if there is an ID, print it

Der Punkt ist, dass Sie wissen, dass es einen Nicht-Null-Angestellten- Service gibt , so dass Sie das in einem Optionalmit einschließen können Optional.of(). Wenn Sie darauf zurückgreifen getEmployee(), erhalten Sie möglicherweise einen Mitarbeiter oder nicht. Dieser Mitarbeiter hat möglicherweise (oder möglicherweise auch nicht) einen Ausweis. Wenn Sie dann eine ID erhalten haben, möchten Sie diese ausdrucken.

Es gibt keine Notwendigkeit, explizit für überprüft jeden null, Präsenz, usw., in diesem Code.

Es ist so gut wie kein Mehrwert, Optionaleinen einzigen Wert zu haben. Wie Sie gesehen haben, ersetzt dies nur einen Scheck auf nulldurch einen Scheck auf Anwesenheit.

Es ist ein enormer Mehrwert, Collectionsolche Dinge zu haben. Alle Streaming-Methoden, die eingeführt wurden, um Low-Level-Loops alten Stils zu ersetzen, verstehen die OptionalDinge und machen das Richtige daraus (sie werden nicht verarbeitet oder geben letztendlich eine andere nicht gesetzte zurück Optional). Wenn Sie sich häufiger mit n Elementen beschäftigen als mit einzelnen Elementen (und 99% aller realistischen Programme), ist es eine enorme Verbesserung, über eine integrierte Unterstützung für optional vorhandene Elemente zu verfügen. Im Idealfall müssen Sie nie nachsehen null oder anwesend sein.

Solange Sie Optionalwie eine ausgefallene API für verwenden isNotNull(), werden Sie keine Unterschiede feststellen, wenn Sie nur nachsehen null.

Dinge , die Sie sollten nicht verwenden Optionalfür

Mit Optionalnur auf das Vorhandensein eines Wertes zu überprüfen , ist Bad - Code ™:

// BAD CODE ™ --  just check getEmployee() != null  
Optional<Employee> employeeOptional =  Optional.ofNullable(employeeService.getEmployee());  
if(employeeOptional.isPresent()) {  
    Employee employee = employeeOptional.get();  
    System.out.println(employee.getId());
}  

Dinge , die Sie verwenden sollten Optionalfür

Vermeiden Sie, dass ein Wert nicht vorhanden ist, indem Sie bei Verwendung von null-zurückgegebenen API-Methoden bei Bedarf einen erstellen:

Employee employee = Optional.ofNullable(employeeService.getEmployee())
                            .orElseGet(Employee::new);
System.out.println(employee.getId());

Oder wenn das Erstellen eines neuen Mitarbeiters zu kostspielig ist:

Optional<Employee> employee = Optional.ofNullable(employeeService.getEmployee());
System.out.println(employee.map(Employee::getId).orElse("No employee found"));

Machen Sie außerdem alle darauf aufmerksam, dass Ihre Methoden möglicherweise keinen Wert zurückgeben (falls Sie aus irgendeinem Grund keinen Standardwert wie oben zurückgeben können):

// Your code without Optional
public Employee getEmployee() {
    return someCondition ? null : someEmployee;
}
// Someone else's code
Employee employee = getEmployee(); // compiler doesn't complain
// employee.get...() -> NPE awaiting to happen, devs criticizing your code

// Your code with Optional
public Optional<Employee> getEmployee() {
    return someCondition ? Optional.empty() : Optional.of(someEmployee);
}
// Someone else's code
Employee employee = getEmployee(); // compiler complains about incompatible types
// Now devs either declare Optional<Employee>, or just do employee = getEmployee().get(), but do so consciously -- not your fault.

Und schließlich gibt es all Stream-ähnliche Methoden , die bereits in anderen Antworten erklärt worden, obwohl diejenigen , die nicht wirklich sind Sie entscheiden , zu verwenden , Optionalaber die Verwendung der Herstellung Optionalvon jemandem anderen zur Verfügung gestellt.

Der entscheidende Punkt für mich bei der Verwendung von Optional ist, dass klar bleibt, wann der Entwickler überprüfen muss, ob die Funktion einen Wert zurückgibt oder nicht.

//service 1
Optional<Employee> employeeOptional = employeeService.getEmployee();
if(employeeOptional.isPresent()){
    Employee employeeOptional= employeeOptional.get();
    System.out.println(employee.getId());
}

//service 2
Employee employee = employeeService.getEmployeeXTPO();
System.out.println(employee.getId());

Ihr Hauptfehler ist, dass Sie immer noch prozeduraler denken. Dies ist nicht als Kritik an Ihnen als Person gedacht, sondern lediglich eine Beobachtung. Funktionaleres Denken ist mit Zeit und Übung verbunden, und daher sind die Methoden „Präsentieren“ und „Schauen“, wie die offensichtlichsten richtigen Dinge aussehen, die für Sie in Frage kommen. Ihr zweiter kleiner Fehler ist das Erstellen Ihrer Option in Ihrer Methode. Die Option soll dokumentieren, dass etwas einen Wert zurückgeben kann oder nicht. Sie könnten nichts bekommen.

Dies hat dazu geführt, dass Sie perfekt lesbaren Code geschrieben haben, der absolut vernünftig erscheint, aber Sie wurden von den abscheulichen Zwillingsversuchern verführt, die get und isPresent sind.

Natürlich wird die Frage schnell: "Warum sind wir präsent und kommen auch dort an?"

Eine Sache, die viele Leute hier vermissen, ist, dass isPresent () ist, dass es nicht für neuen Code gemacht ist, der von Leuten geschrieben wurde, die voll an Bord sind und wissen, wie verdammt nützliche Lambdas sind und wer die funktionale Sache mag.

Es gibt uns jedoch ein paar (zwei) gute, großartige, glamouröse (?) Vorteile:

• Es vereinfacht den Übergang von altem Code, um die neuen Funktionen zu nutzen.
• Es erleichtert die Lernkurven von Optional.

Der erste ist ziemlich einfach.

Stellen Sie sich vor, Sie haben eine API, die so aussieht:

public interface SnickersCounter {
  /** 
   * Provides a proper count of how many snickers have been consumed in total.
   */
  public SnickersCount howManySnickersHaveBeenEaten();

  /**
    * returns the last snickers eaten.<br>
    * If no snickers have been eaten null is returned for contrived reasons.
    */
  public Snickers lastConsumedSnickers();
}

Und Sie hatten eine Legacy-Klasse, die dies als solches verwendete (füllen Sie die Lücken aus):

Snickers lastSnickers = snickersCounter.lastConsumedSnickers();
if(null == lastSnickers) {
  throw new NoSuchSnickersException();
}
else {
  consumer.giveDiabetes(lastSnickers);
}

Ein erfundenes Beispiel, um sicher zu sein. Aber ertrage es hier mit mir.

Java 8 wurde nun gestartet und wir bemühen uns, an Bord zu kommen. Eines der Dinge, die wir tun, ist, dass wir unsere alte Schnittstelle durch etwas ersetzen möchten, das Optional zurückgibt. Warum? Denn wie jemand anderes schon gnädig gesagt hat: Dies nimmt die Vermutung auf sich, ob etwas null sein kann oder nicht. Dies wurde bereits von anderen hervorgehoben. Aber jetzt haben wir ein Problem. Stellen Sie sich vor, wir haben (entschuldigen Sie, während ich bei einer unschuldigen Methode Alt + F7 drücke) 46 Stellen, an denen diese Methode in gut getestetem Legacy-Code aufgerufen wird, der ansonsten hervorragende Arbeit leistet. Jetzt müssen Sie alle aktualisieren.

Hier erstrahlt isPresent.

Denn jetzt: Snickers lastSnickers = snickersCounter.lastConsumedSnickers (); if (null == lastSnickers) {wirf eine neue NoSuchSnickersException (); } else {consumer.giveDiabetes (lastSnickers); }

wird:

Optional<Snickers> lastSnickers = snickersCounter.lastConsumedSnickers();
if(!lastSnickers.isPresent()) {
  throw new NoSuchSnickersException();
}
else {
  consumer.giveDiabetes(lastSnickers.get());
}

Und dies ist eine einfache Änderung, die Sie dem neuen Junior geben können: Er kann etwas Nützliches tun und gleichzeitig die Codebasis erkunden. Win-Win. Immerhin ist so etwas ziemlich verbreitet. Und jetzt müssen Sie den Code nicht mehr umschreiben, um Lambdas oder ähnliches zu verwenden. (In diesem speziellen Fall wäre es trivial, aber ich überlasse es dem Leser, sich Beispiele auszudenken, bei denen es als Übung schwierig wäre.)

Beachten Sie, dass dies bedeutet, dass die Art und Weise, wie Sie dies getan haben, im Wesentlichen ein Weg ist, mit Legacy-Code umzugehen, ohne kostspielige Umschreibungen vorzunehmen. Was ist mit neuem Code?

Nun, in Ihrem Fall, in dem Sie nur etwas ausdrucken möchten, tun Sie einfach Folgendes:

snickersCounter.lastConsumedSnickers (). ifPresent (System.out :: println);

Das ist ziemlich einfach und vollkommen klar. Der Punkt, der dann langsam an die Oberfläche sprudelt, ist, dass es Use Cases für get () und isPresent () gibt. Mit ihnen können Sie vorhandenen Code mechanisch ändern, um die neueren Typen zu verwenden, ohne zu viel darüber nachzudenken. Was Sie tun, ist daher auf folgende Weise falsch:

• Sie rufen eine Methode auf, die möglicherweise null zurückgibt. Die richtige Idee wäre, dass die Methode null zurückgibt.
• Sie verwenden die herkömmlichen Bandaid-Methoden, um dieses optionale Problem zu lösen, anstatt die leckeren neuen Methoden zu verwenden, die Lambda-Phantasie enthalten.

Wenn Sie Optional als einfache Null-Sicherheitsüberprüfung verwenden möchten, sollten Sie Folgendes tun:

new Optional.ofNullable(employeeServive.getEmployee())
    .map(Employee::getId)
    .ifPresent(System.out::println);

Natürlich sieht die gut aussehende Version so aus:

employeeService.getEmployee()
    .map(Employee::getId)
    .ifPresent(System.out::println);

Übrigens, obwohl es keinesfalls erforderlich ist, empfehle ich, pro Operation eine neue Zeile zu verwenden, damit es einfacher zu lesen ist. Leicht zu lesende und verständliche Beats prägnant an jedem Wochentag.

Dies ist natürlich ein sehr einfaches Beispiel, in dem es einfach ist, alles zu verstehen, was wir versuchen zu tun. Im wirklichen Leben ist es nicht immer so einfach. Beachten Sie jedoch, dass wir in diesem Beispiel unsere Absichten zum Ausdruck bringen. Wir möchten den Mitarbeiter abrufen, seinen Ausweis abrufen und ihn, falls möglich, ausdrucken. Dies ist der zweite große Gewinn mit Optional. Dadurch können wir klareren Code erstellen. Ich denke auch, dass es im Allgemeinen eine gute Idee ist, Dinge wie die Erstellung einer Methode zu tun, die eine Reihe von Dingen ausführt, damit Sie sie einer Karte hinzufügen können.

Ich sehe keinen Vorteil in Stil 2. Sie müssen immer noch erkennen, dass Sie die Nullprüfung benötigen, und jetzt ist sie noch größer und daher weniger lesbar.

Ein besserer Stil wäre, wenn employeeServive.getEmployee () den Wert Optional zurückgibt und der Code dann wie folgt lautet:

Optional<Employee> employeeOptional = employeeServive.getEmployee();
if(employeeOptional.isPresent()){
    Employee employee= employeeOptional.get();
    System.out.println(employee.getId());
}

Auf diese Weise können Sie "employeeServive.getEmployee (). GetId ()" nicht aufrufen, und Sie bemerken, dass Sie mit optionalem Wert irgendwie umgehen sollten. Und wenn in Ihrer gesamten Codebasis Methoden nie null zurückgeben (oder fast nie, wenn Ihrem Team Ausnahmen von dieser Regel bekannt sind), erhöht dies die Sicherheit gegen NPE.

Ich denke, der größte Vorteil ist, dass wenn Ihre Methodensignatur eine zurückgibt, EmployeeSie nicht auf Null prüfen. Sie wissen durch diese Unterschrift, dass die Rückgabe eines Mitarbeiters garantiert ist. Sie müssen keinen Fehlerfall behandeln. Mit einem optionalen wissen Sie, was Sie tun.

In Code, den ich gesehen habe, gibt es Nullprüfungen, die niemals fehlschlagen werden, da die Benutzer den Code nicht nachverfolgen möchten, um festzustellen, ob eine Null möglich ist, sodass sie überall defensiv Nullprüfungen durchführen. Das macht den Code etwas langsamer, aber was noch wichtiger ist, es macht den Code viel lauter.

Damit dies funktioniert, müssen Sie dieses Muster jedoch konsistent anwenden.

Meine Antwort lautet: Tu es einfach nicht. Überlegen Sie sich mindestens zweimal, ob es sich wirklich um eine Verbesserung handelt.

Ein Ausdruck (entnommen aus einer anderen Antwort) wie

Optional.of(employeeService)                 // definitely have the service
        .map(EmployeeService::getEmployee)   // getEmployee() might return null
        .map(Employee::getId)                // get ID from employee if there is one
        .ifPresent(System.out::println);     // and if there is an ID, print it

scheint die richtige funktionale Art zu sein, mit ursprünglich nullfähigen Rückgabemethoden umzugehen. Es sieht gut aus, wirft nie und bringt Sie nie dazu, über die Behandlung des "abwesenden" Falls nachzudenken.

Es sieht besser aus als im alten Stil

Employee employee = employeeService.getEmployee();
if (employee != null) {
    ID id = employee.getId();
    if (id != null) {
        System.out.println(id);
    }
}

das macht es offensichtlich, dass es elseKlauseln geben kann .

Der funktionale Stil

• sieht völlig anders aus (und ist nicht lesbar für Leute, die nicht daran gewöhnt sind)
• ist ein Schmerz zu debuggen
• kann nicht einfach erweitert werden, um den "abwesenden" Fall zu behandeln (reicht orElsenicht immer aus)
• irreführend, wenn der Fall "abwesend" ignoriert wird

In keinem Fall sollte es als Allheilmittel verwendet werden. Wenn es universell anwendbar war, sollte die Semantik des .Operators durch die Semantik des ?.Operators ersetzt , die NPE vergessen und alle Probleme ignoriert werden.

Obwohl ich ein großer Java-Fan bin, muss ich sagen, dass der funktionale Stil nur ein Ersatz für die Aussage eines armen Java-Mannes ist

employeeService
.getEmployee()
?.getId()
?.apply(id => System.out.println(id));

bekannt aus anderen Sprachen. Stimmen wir dieser Aussage zu?

• ist nicht (wirklich) funktionsfähig?
• ist dem alten Code sehr ähnlich, nur viel einfacher?
• ist viel lesbarer als der funktionale Stil?
• ist Debugger-freundlich?

Optional ist ein Konzept (ein Typ höherer Ordnung) aus der funktionalen Programmierung. Durch die Verwendung entfällt die Überprüfung auf verschachtelte Nullen und Sie werden vor der Pyramide des Untergangs bewahrt.