従来のヌルポインターチェックの代わりにJava 8以降でOptionalを使用する理由

最近、Java 8に移行しました。今、アプリケーションがOptionalオブジェクトであふれていることがわかります。

Java 8（スタイル1）より前

Employee employee = employeeServive.getEmployee();

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

Java 8（スタイル2）の後

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

Optional<Employee> employeeOptional = employeeService.getEmployee();サービス自体がオプションを返すときの付加価値はありません：

Java 6のバックグラウンドから来た私は、スタイル1がより明確で、コードの行が少ないと考えています。ここに欠けている本当の利点はありますか？

すべての回答からの理解とブログでのさらなる調査から統合

スタイル2は、Java 8を完全に活用するには十分ではありません。あなたはまったく望んでいませんif ... use。Oracleの例を参照してください。彼らのアドバイスを受けて、私たちは以下を得る：

スタイル3

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

または、より長いスニペット

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

Optionalまだ返される可能性のある古いAPI間の「互換性」レイヤーとして使用している場合、何かを持ってnullいると確信できる最新の段階で（空ではない）オプションを作成すると役立ちます。たとえば、あなたが書いた場所：

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

私はに向けて選ぶ：

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

ポイントは、null以外の従業員サービスがあることを知っているため、それをwith でラップできることです。それから、あなたがそれを呼び出すとき、あなたは従業員を得るかもしれないし、そうでないかもしれない。その従業員はIDを持っている場合があります（または場合によっては持っていない場合があります）。次に、IDで終わった場合、それを印刷します。OptionalOptional.of()getEmployee()

明示的にチェックする必要はありませんいかなるなどヌル、存在が、このコードでは、。

Optional単一の値を持つ場合、付加価値はほとんどありません。これまで見てきたように、それnullはチェックをプレゼンスのチェックに置き換えるだけです。

そのようなものを持つことには大きな付加価値がありCollectionます。古いスタイルの低レベルループを置き換えるために導入されたすべてのストリーミングメソッドOptionalは、物事を理解し、それらについて正しいことを行います（処理せず、最終的に別のunsetを返しますOptional）。個々のアイテムよりも頻繁にn個のアイテムを処理する場合（そして現実的なプログラムすべての99％が処理する場合）、オプションで表示するものを組み込みでサポートすることは大きな改善です。理想的なケースではnull 、存在や存在を確認する必要はありません。

のOptionalためisNotNull()に派手なAPIのように使用する限り、そうであれば、をチェックするだけで違いを見つけることはできませんnull。

あなたが使用してはならないもののOptionalために

Optional値の存在を確認するためだけに使用するのは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());
}  

あなたが使うべきものOptionalのために

nullを返すAPIメソッドを使用するときに必要に応じて値を生成することにより、存在しない値を避けます。

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

または、新しい従業員の作成に費用がかかりすぎる場合：

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

また、メソッドが値を返さない可能性があることをすべての人に認識させます（何らかの理由で上記のようなデフォルト値を返せない場合）：

// 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.

そして最後に、他の回答ですでに説明されているすべてのストリームのようなメソッドがありますが、それらは実際に使用することを決定するのではOptionalなく、Optional他の誰かが提供するものを使用します。

オプションを使用する際の重要なポイントは、開発者が関数の戻り値かどうかを確認する必要があるときに明確にすることです。

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

あなたの主な間違いは、あなたがまだより手続き的な観点から考えていることです。これはあなたを人として批判することではなく、単なる観察です。より機能的な用語で考えるには時間と練習が必要です。したがって、メソッドはisPresentであり、最も明らかな正しい呼び出しのように見えます。二次的な小さな間違いは、メソッド内でOptionalを作成することです。Optionalは、何かが値を返す場合と返さない場合があることを文書化するのに役立ちます。何も得られないかもしれません。

これにより、完全に合理的と思われる完全に読みやすいコードを作成できましたが、getおよびisPresentである下劣な双子の誘惑に魅了されました。

もちろん、質問はすぐに「なぜ存在し、そこに到達するのか」になります。

ここで多くの人が見逃しているのは、isPresent（）はgosh-darnの有用なラムダがどれほど機能的で機能的なものが好きなのかを完全に理解している人々によって書かれた新しいコードのために作られたものではないということです。

ただし、いくつかの（2つの）良い、素晴らしい、魅力的な（？）メリットがあります。

• 新しい機能を使用するためのレガシーコードの移行が容易になります。
• Optionalの学習曲線を容易にします。

最初のものはかなり単純です。

次のようなAPIがあるとします。

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

そして、あなたはこれを使用してレガシークラスを持っていました（空白を埋める）：

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

確かに不自然な例。しかし、ここで我慢してください。

Java 8がリリースされ、私たちは急いで乗ろうとしています。そのため、私たちが行うことの1つは、古いインターフェイスをOptionalを返すものに置き換えたいということです。どうして？他の誰かがすでに優雅に述べているように： これは何かがnullになる可能性があるかどうかの推測を取り除きます これはすでに他の人によって指摘されています。しかし今、問題があります。想像してみてください（無実のメソッドでalt + F7を押している間、すみません）、このメソッドがよくテストされたレガシーコードで呼び出され、それ以外の場合は素晴らしい仕事をする46の場所。次に、これらすべてを更新する必要があります。

これはisPresentが輝くところです。

なぜなら今：Snickers lastSnickers = snickersCounter.lastConsumedSnickers（）; if（null == lastSnickers）{新しいNoSuchSnickersException（）を投げます; } else {consumer.giveDiabetes（lastSnickers）; }

になる：

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

そして、これはあなたが新しい後輩に与えることができる簡単な変更です。彼は何か便利なことをすることができ、同時にコードベースを探索することができます。ウィンウィン。結局のところ、このパターンに似たものがかなり普及しています。そして今、ラムダなどを使用するためにコードを書き直す必要はありません。（この特定の場合、それは些細なことですが、読者への演習としてそれが難しい場合の例を考えてみましょう。）

これは、その方法が本質的に、コストのかかる書き換えを行わずにレガシーコードを処理する方法であることを意味していることに注意してください。では、新しいコードはどうでしょうか？

まあ、あなたの場合、あなたが何かを印刷したいだけなら、あなたは単にそうするでしょう：

snickersCounter.lastConsumedSnickers（）。ifPresent（System.out :: println）;

これは非常に単純で、完全に明確です。ゆっくりと表面まで泡立っている点は、get（）とisPresent（）のユースケースが存在するということです。それらは、既存のコードを機械的に変更して、新しいタイプをあまり考慮せずに使用できるようにするためのものです。したがって、あなたがしていることは、次のように見当違いです。

• nullを返す可能性のあるメソッドを呼び出しています。正しい考えは、メソッドがnullを返すことです。
• ラムダファンシーネスを含むおいしい新しいメソッドを使用する代わりに、レガシーの絆創膏メソッドを使用してこのオプションを処理しています。

Optionalを単純なnull安全性チェックとして使用したい場合は、次のようにする必要があります。

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

もちろん、この見栄えの良いバージョンは次のようになります。

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

ちなみに、それは決して必要ではありませんが、読みやすくするために、操作ごとに新しい行を使用することをお勧めします。曜日を問わず、ビートの簡潔さを読み、理解しやすい。

これはもちろん、私たちがやろうとしていることすべてを理解するのが簡単な非常に単純な例です。実生活では必ずしもこれが単純なわけではありません。しかし、この例では、私たちが表現しているのは私たちの意図であることに注意してください。従業員を取得し、IDを取得し、可能であれば印刷します。これはOptionalの2番目の大きな勝利です。これにより、より明確なコードを作成できます。また、多くのことを行うメソッドを作成して、マップにフィードできるようにすることも、一般的には良い考えだと思います。

スタイル2には利点がありません。nullチェックが必要であることに気づく必要がありますが、今ではさらに大きくなり、読みにくくなりました。

employeeServive.getEmployee（）がOptionalを返すと、コードは次のようになります。

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

この方法では、employeeServive.getEmployee（）。​​getId（）を呼び出すことができず、オプションのバロエを何らかの方法で処理する必要があることに気付きます。また、コードベースメソッド全体でnullが返されない場合（または、このルールの例外がチームによく知られている場合はほとんどありません）、NPEに対する安全性が向上します。

最大の利点は、メソッドシグネチャがを返す場合、nullをチェックしないEmployeeことです。その署名によって、従業員を返すことが保証されていることがわかります。失敗のケースを処理する必要はありません。オプションで、あなたはあなたが知っています。

私が見たコードでは、nullが可能かどうかを判断するためにコードをトレースしたくないため、決して失敗しないnullチェックがあります。これにより、コードが少し遅くなりますが、さらに重要なことは、コードのノイズが大きくなることです。

ただし、これが機能するには、このパターンを一貫して適用する必要があります。

私の答えは：しないでください。少なくともそれが本当に改善されているかどうかをよく考えてください。

次のような表現（別の回答から取得）

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

は、元々nullを返すことができるメソッドを処理する正しい機能的な方法のようです。見栄えがよく、投げられず、「不在」のケースの処理について考えることもありません。

古いスタイルの方法よりも良く見える

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

これにより、else条項がある場合があることが明らかになります。

機能的なスタイル

• 見た目は完全に異なります（使用していない人には読めません）
• デバッグするのが大変です
• 「不在」のケースを処理するために簡単に拡張することはできません（orElse常に十分とは限りません）
• 「不在」のケースを無視するように誤解を招く

決して万能薬として使用するべきではありません。それが普遍的に適用可能であった場合、.演算子のセマンティクスは?.演算子のセマンティクスに置き換えられるべきであり、NPEは忘れられ、すべての問題は無視されます。

Javaの大ファンである一方で、私は機能的なスタイルは文のJavaの貧しい男の代わりに過ぎないと言う必要があります。

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

他の言語からよく知られています。この声明に同意しますか

• （本当に）機能していない？
• 古いスタイルのコードに非常に似ていますが、はるかに単純ですか？
• 機能的なスタイルよりもはるかに読みやすいですか？
• デバッガーフレンドリーですか？

オプションは、関数型プログラミングに由来する概念（高次型）です。これを使用すると、ネストされたnullチェックがなくなり、運命のピラミッドからあなたを救います。