对于每个Java开发人员来说，这是一个非常常见的问题。因此，Java8中有官方支持来解决这些问题，而不会产生混乱的代码。

Java 8引入了Java.util.Optional＜T＞。它是一个可以容纳或不容纳非空值的容器。Java8提供了一种更安全的方法来处理在某些情况下值可能为空的对象。它的灵感来自Haskell和Scala的想法。

简而言之，Optional类包含显式处理值存在或不存在的情况的方法。然而，与空引用相比，Optional＜T＞类的优点是，当值不存在时，强制您考虑情况。因此，可以防止意外的空指针异常。

在上面的示例中，我们有一个家庭服务工厂，它向家庭中可用的多个设备返回句柄。但这些服务可能可用或不可用；这意味着它可能会导致NullPointerException。与其在使用任何服务之前添加null if条件，不如将其包装到Optional＜service＞中。

包装到选项<T>

让我们考虑一种从工厂获取服务引用的方法。与其返回服务引用，不如用Optional包装它。它让API用户知道返回的服务可能不可用/不起作用，可以防御性地使用

public Optional<Service> getRefrigertorControl() {
      Service s = new  RefrigeratorService();
       //...
      return Optional.ofNullable(s);
   }

如您所见，Optional.Nullable（）提供了一种简单的方式来包装引用。还有其他方法可以获取Optional的引用，Optional.empty（）和Optional.of（）。一种方法用于返回空对象而不是重新调整null，另一种方法分别包装不可为null的对象。

那么，如何避免空检查呢？

包装引用对象后，Optional提供了许多有用的方法来调用包装引用上的方法，而无需NPE。

Optional ref = homeServices.getRefrigertorControl();
ref.ifPresent(HomeServices::switchItOn);

Optional.ifRepresent调用具有引用的给定Consumer（如果它是非空值）。否则，它什么也不做。

@FunctionalInterface
public interface Consumer<T>

表示接受单个输入参数但不返回结果的操作。与大多数其他功能界面不同，Consumer预期通过副作用进行操作。它很干净，很容易理解。在上面的代码示例中，如果Optional保持引用为非空，则调用HomeService.switchOn（Service）。

我们经常使用三元运算符来检查空条件，并返回替代值或默认值。可选提供了另一种处理相同条件而不检查null的方法。Optional.orElse（defaultObj）如果Optional具有空值，则返回defaultObj。让我们在示例代码中使用它：

public static Optional<HomeServices> get() {
    service = Optional.of(service.orElse(new HomeServices()));
    return service;
}

现在HomeServices.get（）做了同样的事情，但方式更好。它检查服务是否已初始化。如果是，则返回相同的或创建新的new服务。可选＜T＞。或Else（T）有助于返回默认值。

最后，这里是我们的NPE以及无空检查代码：

import java.util.Optional;
public class HomeServices {
    private static final int NOW = 0;
    private static Optional<HomeServices> service;

public static Optional<HomeServices> get() {
    service = Optional.of(service.orElse(new HomeServices()));
    return service;
}

public Optional<Service> getRefrigertorControl() {
    Service s = new  RefrigeratorService();
    //...
    return Optional.ofNullable(s);
}

public static void main(String[] args) {
    /* Get Home Services handle */
    Optional<HomeServices> homeServices = HomeServices.get();
    if(homeServices != null) {
        Optional<Service> refrigertorControl = homeServices.get().getRefrigertorControl();
        refrigertorControl.ifPresent(HomeServices::switchItOn);
    }
}

public static void switchItOn(Service s){
         //...
    }
}

完整的帖子是NPE以及空检查免费代码…真的吗？。

根据所检查的对象类型，您可以使用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");

我们一直在使用Apache库（Apache Commons）解决这个问题。

ObjectUtils.equals(object, null)

or

CollectionUtils.isEmpty(myCollection);

or

StringUtils.isEmpty("string");

作为一种实践，我喜欢前面的回答，即为集合提供初始默认值或空集，以最小化需要。

这些可以是防止出现NullPointerException或使用空集合的简单用法。这并不能回答如何处理空对象的问题，但它们为对象或集合的基本验证提供了一些检查。

希望这有帮助。

您可以使用类似JUnit的框架将类与单元测试相结合。这样，您的代码将是干净的（没有无用的检查），并且您将确保您的实例不会为空。

这是使用单元测试的一个很好的理由。

对于Java8或更新版本，最好的选择可能是使用Optional类。

Optional stringToUse = Optional.of("optional is there");
stringToUse.ifPresent(System.out::println);

这对于可能的空值的长链来说尤其方便。例子：

Optional<Integer> i = Optional.ofNullable(wsObject.getFoo())
    .map(f -> f.getBar())
    .map(b -> b.getBaz())
    .map(b -> b.getInt());

如何在null上引发异常的示例：

Optional optionalCarNull = Optional.ofNullable(someNull);
optionalCarNull.orElseThrow(IllegalStateException::new);

Java7引入了Objects.requireOnNull方法，当需要检查某些内容是否为非空时，该方法非常方便。例子：

String lowerVal = Objects.requireNonNull(someVar, "input cannot be null or empty").toLowerCase();

有一种很好的方法来检查JDK中的空值。Optional.java有大量解决这些问题的方法。例如：

    /**
     * Returns an {@code Optional} describing the specified value, if non-null,
     * otherwise returns an empty {@code Optional}.
     *
     * @param <T> the class of the value
     * @param value the possibly-null value to describe
     * @return an {@code Optional} with a present value if the specified value
     * is non-null, otherwise an empty {@code Optional}
     */
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

    /**
     * Return {@code true} if there is a value present, otherwise {@code false}.
     *
     * @return {@code true} if there is a value present, otherwise {@code false}
     */
    public boolean isPresent() {
        return value != null;
    }

    /**
     * If a value is present, invoke the specified consumer with the value,
     * otherwise do nothing.
     *
     * @param consumer block to be executed if a value is present
     * @throws NullPointerException if value is present and {@code consumer} is
     * null
     */
    public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }

帮助标枪真的非常非常有用。