对于每个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以及空检查免费代码…真的吗？。

public class Null {

public static void main(String[] args) {
    String str1 = null;
    String str2 = "";

    if(isNullOrEmpty(str1))
        System.out.println("First string is null or empty.");
    else
        System.out.println("First string is not null or empty.");

    if(isNullOrEmpty(str2))
        System.out.println("Second string is null or empty.");
    else
        System.out.println("Second string is not null or empty.");
}

public static boolean isNullOrEmpty(String str) {
    if(str != null && !str.isEmpty())
        return false;
    return true;
}
}

输出

str1 is null or empty.
str2 is null or empty.

在上面的程序中，我们有两个字符串str1和str2。str1包含空值，str2为空字符串。

我们还创建了一个函数isNullOrEmpty（），顾名思义，它检查字符串是空还是空。它使用！=进行空检查null和字符串的isEmpty（）方法。

简单地说，如果字符串不是null并且isEmpty（）返回false，那么它既不是null也不是空的。否则，就是这样。

但是，如果字符串只包含空白字符（空格），则上述程序不会返回空。从技术上讲，isEmpty（）看到它包含空格并返回false。对于带空格的字符串，我们使用string方法trim（）来删除所有前导和尾随空格字符。

我更喜欢这个

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

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

对于实用程序类，可以检查参数是否为空。

在所有其他情况下，您可能不必这样做。尽可能使用封装，从而减少您想检查null的地方。

好的，我现在已经从技术上回答了一百万次，但我不得不这么说，因为这是一场与Java程序员的无休止的讨论。

很抱歉，我不同意以上所有内容。我们必须在Java中测试null的原因是，Java程序员一定不知道如何处理内存。

我这么说是因为我有很长的C++编程经验，而我们不这么做。换句话说，你不需要这样做。注意，在Java中，如果你命中了一个悬空指针，你会得到一个正常的异常；在C++中，此异常通常不会被捕获并终止程序。

不想这样做吗？然后遵循C/C++中的一些简单规则。

不要轻易实例化事物，认为每一个“新”都会给你带来很多麻烦，并遵循这些简单的规则。

一个类只能通过3种方式访问内存->

它可以“拥有”类成员，他们将遵循以下规则：所有“HAS”成员都是在构造函数中“新建”的。您将在析构函数或等效的close（）中关闭/取消分配同一类的Java函数，而不是其他类。

这意味着您需要记住（就像Java一样）谁是每个资源的所有者或父级，并尊重该所有权。对象只能由创建它的类删除。此外->

一些成员将被“使用”，但不拥有或“拥有”。这是另一个类中的“OWN”，并作为参数传递给构造函数。由于这些是由另一个类拥有的，我们永远不会删除或关闭它，只有父类才能删除或关闭。类中的方法还可以实例化本地对象供内部使用，这些对象永远不会传递到类的外部，或者它们应该是正常的“有”对象。

最后，要使所有这些工作正常进行，您需要有一个严格的设计，以层次结构形式使用类，并且不进行循环。

在这种设计下，遵循上述规则，层次结构设计中的子类不可能访问被破坏的指针，因为这意味着父类在子类之前被破坏，而层次结构非循环设计不允许这样做。

最后，还要记住，在启动系统时，应该从上到下构建层次结构，并从下到上销毁。任何地方都不会有空指针，或者有人违反了规则。

空对象模式可以用作此问题的解决方案。为此，应该修改someObject的类。

public abstract class SomeObject {
   public abstract boolean isNil();
}

public class NullObject extends SomeObject {
   @Override
   public boolean isNil() {
      return true;
   }
}
public class RealObject extends SomeObject {
   @Override
   public boolean isNil() {
      return false;
   }
}

现在先检查一下，

 if (someobject != null) {
    someobject.doCalc();
}

我们可以使用，

if (!someObject.isNil()) {
   someobject.doCalc();
}

参考：https://www.tutorialspoint.com/design_pattern/null_object_pattern.htm