您可以为对象和字符串创建一个通用方法，以便在应用程序中完全使用它-这可以帮助您和您的同事：创建一个类，例如StringUtilities，并添加方法，例如getNullString

public static String getNullString(Object someobject)
{
   if(null==someobject )
        return null;

   else if(someobject.getClass().isInstance("") && 
          (((String)someobject).trim().equalsIgnoreCase("null")|| 
          ((String)someobject).trim().equalsIgnoreCase("")))
        return null;

   else if(someobject.getClass().isInstance(""))
        return (String)someobject;

   else
        return someobject.toString().trim();
}

简单地将此方法称为，

if (StringUtilities.getNullString(someobject) != null)
{ 
  //Do something
}

有一种很好的方法来检查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);
    }

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

如果不允许空值

如果从外部调用方法，请从以下内容开始：

public void method(Object object) {
  if (object == null) {
    throw new IllegalArgumentException("...");
  }

然后，在该方法的其余部分中，您将知道该对象不为空。

如果它是一个内部方法（不是API的一部分），只需记录它不能为空，就可以了。

例子：

public String getFirst3Chars(String text) {
  return text.subString(0, 3);
}

但是，如果您的方法只是传递值，而下一个方法传递值等，则可能会出现问题。在这种情况下，您可能需要检查上述参数。

如果允许为空

这真的取决于。如果发现我经常这样做：

if (object == null) {
  // something
} else {
  // something else
}

所以我分支，做两件完全不同的事情。没有难看的代码片段，因为我确实需要根据数据做两件不同的事情。例如，我应该处理输入，还是应该计算一个好的默认值？

实际上，我很少使用“if（object！=null&&…”这个成语。

如果你展示了你通常使用这个习语的例子，那么给你举例可能会更容易。

无论您在何处传递数组或向量，请将它们初始化为空值，而不是空值。-这样可以避免大量检查null，一切都很好：）

public class NonNullThing {

   Vector vectorField = new Vector();

   int[] arrayField = new int[0];

   public NonNullThing() {

      // etc

   }

}

在我看来，这似乎是初级到中级开发人员在某个时候往往会面临的一个相当普遍的问题：他们要么不知道，要么不信任他们正在参与的合同，并防御性地过度检查空值。此外，在编写自己的代码时，他们倾向于依赖于返回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);
        }
    }
}

如果您使用的是java8或更高版本，请从java.util.Objects获取isNull（yourObject）。

示例：-

String myObject = null;

Objects.isNull(myObject); //will return true

用法：以下代码返回非空值（如果名称不为空，则返回该值，否则返回默认值）。

final String name = "Jobin";
String nonNullValue = Optional.ofNullable(name).orElse("DefaultName");