Java“？” 用于检查null的运算符-这是什么？（不是三元！）

我正在阅读一篇与slashdot故事相关的文章，发现了这个小窍门：

以Java的最新版本为例，该版本试图通过提供无穷指针测试的简写语法来简化空指针检查。只需在每个方法调用中添加一个问号，就会自动包括对空指针的测试，从而替换了鼠的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();
    } 

我搜寻了互联网（好吧，我花了至少15分钟的时间在“ java问号”上搜索了各种变体），但一无所获。所以，我的问题是：是否有任何官方文件？我发现C＃有一个类似的运算符（“ ??”运算符），但是我想获取我正在使用的语言的文档。或者，这仅仅是对我使用的三元运算符的使用从没见过。

谢谢！

编辑：链接到文章：http : //infoworld.com/d/developer-world/12-programming-mistakes-avoid-292

最初的想法来自groovy。它是针对Java 7提出的，作为Project Coin的一部分：https：//wiki.openjdk.java.net/display/Coin/2009+Proposals+TOC（猫王和其他Null-Safe运算符），但尚未被接受。

提出了相关的Elvis运算符？：的x ?: y简称x != null ? x : y，特别适用于x是复杂表达式的情况。

该语法在Java中不存在，也不打算包含在我所知道的任何即将发布的版本中。

Java 7中对此有一个建议，但遭到拒绝：

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

解决缺少“？”的一种方法 使用Java 8且没有try-catch开销（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();
}

[编辑]

经过进一步思考，我发现实际上只有使用标准Java 8类才能实现相同的目的：

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

在这种情况下，甚至可以选择默认值（例如"<no first name>"），而不是null通过将其作为参数传递orElse。

请参阅：https：//blogs.oracle.com/darcy/project-coin：-the- final-five-or- so（特别是“ Elvis和其他null安全运算符”）。

结果是该功能已考虑用于Java 7，但未包括在内。

这实际上是Groovy的安全取消引用运算符。您不能（纯粹）在纯Java中使用它，因此该帖子完全是错误的（如果声称Groovy是“ Java的最新版本”，则可能会产生一些误导）。

Java没有确切的语法，但是从JDK-8开始，我们拥有Optional API，可以使用各种方法。因此，使用空条件运算符的C＃版本：

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

可以使用Optional API在Java中编写如下：

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

如果有的话person，getName或getGivenName为null，则返回null。

可以定义util方法，用Java 8 lambda几乎可以解决这个问题。

这是H-MAN解决方案的一种变体，但它使用带有多个参数的重载方法来处理多个步骤，而不是catch NullPointerException。

即使我认为该解决方案很酷，但我认为我更喜欢Helder Pereira的秒，因为它不需要任何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; }
}

我不确定这是否行得通。如果说人员引用为空，那么运行时将用它替换什么？一个新人？这将要求此人具有您在这种情况下期望的一些默认初始化。您可以避免使用null引用异常，但是如果您不打算针对这些类型的设置进行计划，则仍然会出现无法预测的行为。

?? 最好将C＃中的运算符称为“ coalesce”运算符；您可以链接多个表达式，它将返回第一个不为null的表达式。不幸的是，Java没有它。我认为您最好的办法是使用三元运算符执行null检查，并在链中的任何成员为null的情况下评估整个表达式的替代项：

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

您还可以使用try-catch：

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

有了Java 8中的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中提供的Optional。这可以帮助您实现类似的目标。 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;
  }
}