Java「？」nullをチェックするための演算子-それは何ですか？（三項ではありません！）

私はスラッシュドットの話からリンクされた記事を読んでいて、この小さな一口に出くわしました：

最新バージョンのJavaを使用してください。これは、エンドレスポインターテスト用の簡略構文を提供することにより、nullポインターチェックを容易にすることを目的としています。各メソッド呼び出しに疑問符を追加するだけで、nullポインターのテストが自動的に含まれ、次のようなラットのif-thenステートメントのネストが置き換えられます。

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

これとともに：

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

私はインターネットを調べましたが（わかりました、「javaクエスチョンマーク」のバリエーションをグーグルで検索するのに少なくとも15分費やしました）、何も得られませんでした。だから、私の質問：これに関する公式のドキュメントはありますか？C＃にも同様の演算子（「??」演算子）があることがわかりましたが、使用している言語のドキュメントを入手したいと思います。または、これは私が使用した三項演算子の使用法にすぎません。これまでに見たことはありません。

ありがとう！

編集：記事へのリンク：http：//infoworld.com/d/developer-world/12-programming-mistakes-avoid-292

元のアイデアはグルーヴィーから来ています。プロジェクトコインの一部としてJava7に提案されました：https：//wiki.openjdk.java.net/display/Coin/2009+Proposals+TOC（Elvis and Other Null-Safe Operators）が、まだ受け入れられていません。

関連するエルビス演算子？：は、のx ?: y省略形を作成するために提案されましたx != null ? x : y。特に、xが複素式の場合に役立ちます。

この構文はJavaには存在せず、私が知っている今後のバージョンのいずれにも含まれる予定はありません。

Java 7で提案がありましたが、却下されました。

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

「？」の欠如を回避する1つの方法 try-catchのオーバーヘッドなしでJava8を使用する演算子（NullPointerException前述のように、他の場所で発生したものを非表示にすることもできます）は、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;
    }
}

次に、与えられた例は次のようになります。

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

[編集]

さらに考えてみると、標準のJava8クラスを使用した場合にのみ同じことを実現できることが実際に可能であることがわかりました。

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

この場合、のパラメータとして渡す"<no first name>"代わりに、デフォルト値（のような）を選択することも可能です。nullorElse

参照：https：//blogs.oracle.com/darcy/project-coin：-the-final-five-or-so（具体的には「Elvisおよびその他のヌルセーフ演算子」）を。

その結果、この機能はJava 7で考慮されましたが、含まれていませんでした。

これは実際にはGroovyの安全な間接参照演算子です。純粋なJavaでは（悲しいことに）それを使用できないため、投稿は単に間違っています（または、Groovyが「Javaの最新バージョン」であると主張している場合は、少し誤解を招く可能性があります）。

Javaには正確な構文はありませんが、JDK-8の時点で、さまざまなメソッドを自由に使用できるオプションのAPIがあります。したがって、null条件演算子を使用したC＃バージョン：

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

オプションのAPIを使用してJavaで次のように記述できます。

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

いずれかの場合person、getNameまたはgetGivenNamenullの場合、nullが返されています。

Java8ラムダを使用してこれをほぼきれいな方法で解決するutilメソッドを定義することが可能です。

これはH-MANsソリューションのバリエーションですが、キャッチする代わりに複数のステップを処理するために複数の引数を持つオーバーロードされたメソッドを使用しますNullPointerException。

このソリューションはちょっとクールだと思いますが、utilメソッドを必要としないので、HelderPereiraの2番目のソリューションの方が好きだと思います。

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

これがうまくいくかどうかはわかりません。たとえば、個人参照がnullの場合、ランタイムはそれを何に置き換えますか？新しい人？そのためには、この場合に予想されるデフォルトの初期化が必要になります。null参照の例外を回避することはできますが、これらのタイプのセットアップを計画していなかった場合でも、予測できない動作が発生します。

?? C＃の演算子は、「合体」演算子と呼ばれるのが最適です。複数の式を連鎖させることができ、nullではない最初の式が返されます。残念ながら、Javaにはそれがありません。三項演算子を使用してnullチェックを実行し、チェーン内のいずれかのメンバーがnullの場合は、式全体の代替を評価するのが最善の方法だと思います。

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

try-catchを使用することもできます。

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

これで、Java8でのnullセーフな呼び出しができました。

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

誰かが古いJavaバージョンの代替を探しているなら、私が書いたこれを試すことができます：

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

}

提供したコードをテストすると、構文エラーが発生するため、Javaではサポートされていません。Groovyはそれをサポートしており、Java 7用に提案されました（ただし、含まれることはありませんでした）。

ただし、Java 8で提供されているオプションを使用できます。これは、同様の行で何かを達成するのに役立つ場合があります。 https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html http://www.oracle.com/technetwork/articles/java/java8-optional-2175753.html

オプションのサンプルコード

インストールされているOSが24以上でない限り、AndroidはLambda関数をサポートしないため、リフレクションを使用する必要があります。

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

これがパフォーマンスの問題ではない場合は、次のように書くことができます。

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