在Java8 lambdas中，可以定义以近乎完美的方式处理嵌套空检查的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; }
}

（这个答案首先发布在这里。）

！=的另一种选择空检查是（如果你无法在设计上摆脱它）：

Optional.ofNullable(someobject).ifPresent(someobject -> someobject.doCalc());

or

Optional.ofNullable(someobject).ifPresent(SomeClass::doCalc);

SomeClass是某个对象的类型。

但是，您无法从doCalc（）获取返回值，因此仅对void方法有用。

我更喜欢这个

public void simpleFunc(SomeObject someObject){
    someObject = someObject != null ? someObject : new SomeObject(null);
    someObject.doSomething();
}

当然，在我的示例中，SomeObject优雅地处理空参数。例如，记录这样的事件，不做任何其他操作。

根据所检查的对象类型，您可以使用apachecommons中的一些类，例如：apachecommons-lang和apachecommons集合

例子：

String foo;
...
if( StringUtils.isBlank( foo ) ) {
   ///do something
}

或（取决于您需要检查的内容）：

String foo;
...
if( StringUtils.isEmpty( foo ) ) {
   ///do something
}

StringUtils类只是众多类中的一个；在commons中有相当多的好类可以进行空安全操作。

下面是一个示例，说明当您包含apache库（commons-lang-2.4.jar）时，如何在JAVA中使用空值验证

public DOCUMENT read(String xml, ValidationEventHandler validationEventHandler) {
    Validate.notNull(validationEventHandler,"ValidationHandler not Injected");
    return read(new StringReader(xml), true, validationEventHandler);
}

如果您使用的是Spring，Spring的包中也有相同的功能，请参见库（Spring-2.46.jar）

关于如何使用spring中的静态类f的示例（org.springframework.util.Assert）

Assert.notNull(validationEventHandler,"ValidationHandler not Injected");

在我看来，这似乎是初级到中级开发人员在某个时候往往会面临的一个相当普遍的问题：他们要么不知道，要么不信任他们正在参与的合同，并防御性地过度检查空值。此外，在编写自己的代码时，他们倾向于依赖于返回null来指示某些内容，从而要求调用者检查null。

换言之，有两种情况会出现空检查：

在合同条款中，null为有效响应；和如果它不是有效的响应。

（2） 很容易。从Java1.7开始，您可以使用Objects.requireOnNull（foo）

该方法的“正确”用法如下。该方法返回传递给它的对象，如果对象为空，则抛出NullPointerException。这意味着返回的值总是非空的。该方法主要用于验证参数。

public Foo(Bar bar) {
    this.bar = Objects.requireNonNull(bar);
}

它也可以像断言一样使用，因为如果对象为空，它会抛出异常。在这两种情况下，都可以添加一条消息，该消息将显示在异常中。下面将其用作断言并提供消息。

Objects.requireNonNull(someobject, "if someobject is null then something is wrong");
someobject.doCalc();

当值为null但不应为null时，通常会引发特定异常（如NullPointerException），这有利于引发更一般的异常（如AssertionError）。这是Java库采用的方法；当参数不允许为null时，支持NullPointerException而不是IllegalArgumentException。

（1） 有点难。如果你无法控制正在调用的代码，那么你就被卡住了。如果null是有效的响应，则必须检查它。

然而，如果是由你控制的代码（通常是这样），那就另当别论了。避免使用null作为响应。对于返回集合的方法，很容易：总是返回空集合（或数组）而不是空值。

对于非集合，这可能会更困难。举个例子：如果您有这些接口：

public interface Action {
  void doSomething();
}

public interface Parser {
  Action findAction(String userInput);
}

其中Parser接收原始用户输入并找到要做的事情，如果您正在实现某个命令行接口。现在，如果没有适当的操作，您可能会使契约返回null。这导致了你所说的空值检查。

另一种解决方案是从不返回null，而是使用空对象模式：

public class MyParser implements Parser {
  private static Action DO_NOTHING = new Action() {
    public void doSomething() { /* do nothing */ }
  };

  public Action findAction(String userInput) {
    // ...
    if ( /* we can't find any actions */ ) {
      return DO_NOTHING;
    }
  }
}

比较：

Parser parser = ParserFactory.getParser();
if (parser == null) {
  // now what?
  // this would be an example of where null isn't (or shouldn't be) a valid response
}
Action action = parser.findAction(someInput);
if (action == null) {
  // do nothing
} else {
  action.doSomething();
}

to

ParserFactory.getParser().findAction(someInput).doSomething();

这是一个更好的设计，因为它导致了更简洁的代码。

也就是说，findAction（）方法抛出带有有意义的错误消息的异常可能是完全合适的——尤其是在这种情况下，您依赖于用户输入。findAction方法抛出一个异常比调用方法用简单的NullPointerException（没有解释）爆炸要好得多。

try {
    ParserFactory.getParser().findAction(someInput).doSomething();
} catch(ActionNotFoundException anfe) {
    userConsole.err(anfe.getMessage());
}

或者，如果您认为try/catch机制太难看，而不是Do Nothing，那么您的默认操作应该向用户提供反馈。

public Action findAction(final String userInput) {
    /* Code to return requested Action if found */
    return new Action() {
        public void doSomething() {
            userConsole.err("Action not found: " + userInput);
        }
    }
}

最终，彻底解决这个问题的唯一方法是使用不同的编程语言：

在Objective-C中，你可以在nil上调用一个方法，而绝对不会发生任何事情。这使大多数空检查变得不必要，但会使错误更难诊断。在Nice这一Java派生语言中，所有类型都有两个版本：可能为空的版本和非空的版本。只能对非空类型调用方法。通过显式检查null，可以将可能为null的类型转换为非null类型。这使得更容易知道哪些地方需要空检查，哪些地方不需要空检查。