什么是 NullPointerException，如何修复它？

Question

什么是空指针异常 (java.lang.NullPointerException) 以及导致它们的原因是什么？

可以使用哪些方法/工具来确定原因，以便阻止异常导致程序提前终止？

Answer 1

Java 中有两种主要类型的变量：

1. 基元：包含数据的变量。如果您想操作原始变量中的数据，您可以直接操作该变量。按照惯例，原始类型以小写字母开头。例如，int 或 char 类型的变量是基元。

2. 引用：包含对象内存地址的变量，即引用对象的变量。如果您想要操作引用变量引用的Object，则必须取消引用它。取消引用通常需要使用 . 访问方法或字段，或使用 [ 索引数组。按照惯例，引用类型通常用以大写字母开头的类型来表示。例如，Object 类型的变量是引用。

考虑下面的代码，您声明了 primitive 类型 int 的变量并且不初始化它：

int x;
int y = x + x;

这两行将使程序崩溃，因为没有为 指定值x，我们尝试使用 x 的值来指定 y。所有基元在被操作之前都必须初始化为可用值。

现在事情变得有趣了。 引用变量可以设置为null，这意味着“我没有引用任何东西”。如果您以这种方式显式设置引用变量，则可以在引用变量中获取 null 值，或者引用变量未初始化并且编译器不会捕获它（Java 会自动将该变量设置为 null ）。

如果您显式地或通过 Java 自动将引用变量设置为 null，并且您尝试取消引用它，您将得到一个 NullPointerException。

当您声明变量但在尝试使用变量的内容之前没有创建对象并将其分配给该变量时，通常会发生 NullPointerException (NPE)。所以你引用了一些实际上并不存在的东西。

如下代码：

Integer num;
num = new Integer(10);

第一行声明了一个名为num的变量，但它实际上还不包含引用值。由于您还没有说出要指向什么，Java 将其设置为 null。

第二行，使用new关键字实例化（或创建）一个Integer类型的对象，并赋值引用变量num到该 Integer 对象。

如果您在创建对象之前尝试取消引用 num，您将收到 NullPointerException。在最简单的情况下，编译器会捕获问题并让您知道“num 可能尚未初始化”，但有时您可能会编写不直接创建对象的代码。

例如，您可能有如下方法：

public void doSomething(SomeObject obj) {
   // Do something to obj, assumes obj is not null
   obj.myMethod();
}

在这种情况下，您不会创建对象 obj，而是假设它是在 doSomething() 方法之前创建的被称为。请注意，可以像这样调用该方法：

doSomething(null);

在这种情况下，obj 为 null，并且语句 obj.myMethod() 将抛出 NullPointerException 。

如果该方法打算像上面的方法那样对传入的对象执行某些操作，则抛出 NullPointerException 是适当的，因为这是程序员错误，并且程序员需要该信息来进行调试。

除了由于方法逻辑引发的 NullPointerException 之外，您还可以检查方法参数中是否有 null 值，并通过在方法的开头：

// Throws an NPE with a custom error message if obj is null
Objects.requireNonNull(obj, "obj must not be null");

请注意，在错误消息中明确说明哪个对象不能为null会很有帮助。验证这一点的优点是 1) 您可以返回自己更清晰的错误消息，2) 对于方法的其余部分，您知道除非重新分配 obj ，否则它不为 null 并且可以安全地取消引用。

或者，在某些情况下，该方法的目的不仅仅是对传入的对象进行操作，因此空参数可能是可接受的。在这种情况下，您需要检查空参数并采取不同的行为。您还应该在文档中对此进行解释。例如，doSomething() 可以写为：

/**
  * @param obj An optional foo for ____. May be null, in which case
  *  the result will be ____.
  */
public void doSomething(SomeObject obj) {
    if(obj == null) {
       // Do something
    } else {
       // Do something else
    }
}

最后，如何查明异常&使用堆栈跟踪的原因

可以使用哪些方法/工具来确定原因，以便您停止
导致程序提前终止的异常？

具有 find bug 功能的声纳可以检测 NPE。
sonar能否动态捕获JVM引起的空指针异常

现在 Java 14 添加了一个新的语言功能来显示 NullPointerException 的根本原因。自 2006 年以来，此语言功能已成为 SAP 商业 JVM 的一部分。

在 Java 14 中，以下是 NullPointerException 异常消息示例：

在线程“main”中java.lang.NullPointerException：无法调用“java.util.List.size()”，因为“list”为空

导致 NullPointerException 发生的情况列表

以下是所有Java 语言规范直接*提到了发生 NullPointerException 的情况：

• 访问（即获取或设置）空引用的实例字段。 （静态字段不算数！）
• 调用空引用的实例方法。 （静态方法不算数！）
• throw null;
• 访问 null 数组的元素。
• 空值同步 - synchronized (someNullReference) { ... }
• 如果任何整数/浮点运算符的操作数之一是装箱空引用，则任何整数/浮点运算符都可以抛出 NullPointerException
• 拆箱转换如果装箱值为 null，则抛出 NullPointerException。
• 对 null 引用调用 super 会引发 NullPointerException。如果您感到困惑，这里讨论的是合格的超类构造函数调用：

class Outer {
    class Inner {}
}
class ChildOfInner extends Outer.Inner {
    ChildOfInner(Outer o) { 
        o.super(); // if o is null, NPE gets thrown
    }
}

• 使用 for (element : iterable) 循环来循环访问 null 集合/数组。

• 当 foo 为 null 时，

  switch (foo) { ... }（无论是表达式还是语句）可以抛出 NullPointerException。

• 当 foo 为 null 时，

  foo.new SomeInnerClass() 抛出 NullPointerException。

• name1::name2 或 primaryExpression::name 形式的方法引用在 name1 计算时抛出 NullPointerException code> 或 primaryExpression 计算结果为 null。

  来自 JLS 的注释指出，someInstance.someStaticMethod() 不会抛出 NPE，因为 someStaticMethod 是静态的，但 someInstance:: someStaticMethod 仍然抛出 NPE！

_{* 请注意，JLS 可能还间接谈论了很多有关 NPE 的内容。}

Answer 2

NullPointerException 是当您尝试使用指向内存中任何位置 (null) 的引用（就像引用对象一样）时发生的异常。对空引用调用方法或尝试访问空引用的字段将触发 NullPointerException。这些是最常见的，但 中列出了其他方法NullPointerException javadoc 页面。

我能想到的用于说明 NullPointerException 的最快示例代码可能是：

public class Example {

    public static void main(String[] args) {
        Object obj = null;
        obj.hashCode();
    }

}

在 main 内的第一行，我显式设置了 Object code> 引用 obj 等于 null。这意味着我有一个引用，但它没有指向任何对象。之后，我尝试通过调用该引用的方法来将该引用视为指向一个对象。这会导致 NullPointerException，因为在引用指向的位置没有要执行的代码。

（这是一个技术细节，但我认为值得一提的是：指向 null 的引用与指向无效内存位置的 C 指针不同。空指针实际上不指向任何地方，这与指向恰好无效的位置有细微的不同。）

Answer 3

什么是空指针异常？

JavaDocs 是一个不错的起点。他们涵盖了这个：

当应用程序在以下情况下尝试使用 null 时抛出：
对象是必需的。其中包括：

• 调用 null 对象的实例方法。
• 访问或修改空对象的字段。
• 将 null 的长度视为数组。
• 像数组一样访问或修改 null 的槽。
• 抛出 null 就像它是一个 Throwable 值一样。

应用程序应该抛出此类的实例来指示其他
非法使用 null 对象。

还有一种情况是，如果您尝试将空引用与 synchronized 结合使用，也会引发此异常，根据 JLS：

Synchronized语句：
    同步（表达式）块

• 否则，如果表达式的值为 null，则会引发 NullPointerException。

我该如何修复它？

所以你有一个NullPointerException。你如何解决它？让我们举一个引发 NullPointerException 的简单示例：

public class Printer {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public void print() {
        printString(name);
    }

    private void printString(String s) {
        System.out.println(s + " (" + s.length() + ")");
    }

    public static void main(String[] args) {
        Printer printer = new Printer();
        printer.print();
    }
}

识别 null 值

第一步是准确识别哪些值导致了异常。为此，我们需要进行一些调试。学会阅读堆栈跟踪非常重要。这将显示抛出异常的位置：

Exception in thread "main" java.lang.NullPointerException
    at Printer.printString(Printer.java:13)
    at Printer.print(Printer.java:9)
    at Printer.main(Printer.java:19)

在这里，我们看到异常是在第 13 行（在 printString 方法中）抛出的。查看该行并检查哪些值为空
添加日志语句或使用调试器。我们发现 s 为 null，并且对其调用 length 方法会抛出异常。我们可以看到，当从方法中删除 s.length() 时，程序停止抛出异常。

跟踪这些值的来源

接下来检查该值的来源。通过跟踪该方法的调用者，我们可以看到 s 是通过 print() 方法中的 printString(name) 传入的，并且 <代码> this.name 为空。

跟踪这些值应该在哪里设置

this.name 在哪里设置？在 setName(String) 方法中。通过更多的调试，我们可以看到这个方法根本没有被调用。如果调用该方法，请确保检查这些方法的调用顺序，并且 set 方法不会在 print 方法之后调用。

这足以为我们提供一个解决方案：在调用 printer.print() 之前添加对 printer.setName() 的调用。

其他修复

变量可以有一个默认值（并且setName可以防止它被设置为空）：

private String name = "";

print或printString 方法可以检查 null，例如：

printString((name == null) ? "" : name);

或者您可以设计类，以便 name 始终具有非 null 值 ：

public class Printer {
    private final String name;

    public Printer(String name) {
        this.name = Objects.requireNonNull(name);
    }

    public void print() {
        printString(name);
    }

    private void printString(String s) {
        System.out.println(s + " (" + s.length() + ")");
    }

    public static void main(String[] args) {
        Printer printer = new Printer("123");
        printer.print();
    }
}

另请参阅：

• 在 Java 中避免“!= null”语句？

我仍然找不到问题

如果你尝试调试问题但仍然没有解决方案，您可以发布问题以获取更多帮助，但请确保包含您迄今为止尝试过的内容。至少，在问题中包含堆栈跟踪，并在代码中标记重要的行号。另外，首先尝试简化代码（请参阅SSCCE）。

Answer 4

问题：什么原因导致 NullPointerException (NPE)？

如您所知，Java 类型分为原始类型（boolean、int 等）和引用类型 >。 Java 中的引用类型允许您使用特殊值 null，这是 Java 中表示“无对象”的方式。

每当您的程序尝试使用 null 就好像它是真正的引用一样，就会在运行时引发 NullPointerException 。例如，如果您这样写：

public class Test {
    public static void main(String[] args) {
        String foo = null;
        int length = foo.length();   // HERE
    }
}

标记为“HERE”的语句将尝试在 null 引用上运行 length() 方法，这将抛出 <代码>NullPointerException。

您可以通过多种方式使用 null 值，从而导致 NullPointerException。事实上，在不导致 NPE 的情况下，您可以使用 null 做的唯一事情是：

• 将其分配给引用变量或从引用变量中读取它，
• 将其分配给数组元素或从数组元素读取它（前提是数组引用本身非空！），
• 将其作为参数传递或将其作为结果返回，或
• 使用 == 或!= 运算符，或实例。

问题：如何读取 NPE 堆栈跟踪？

假设我编译并运行上面的程序：

$ javac Test.java 
$ java Test
Exception in thread "main" java.lang.NullPointerException
    at Test.main(Test.java:4)
$

第一个观察结果：编译成功！程序中的问题不是编译错误。这是一个运行时错误。 （有些 IDE 可能会警告你的程序总是会抛出异常......但标准 javac 编译器不会。）

第二个观察结果：当我运行程序时，它输出两行“gobbledy-gook” ”。 错误！！这不是官样文章。它是一个堆栈跟踪......并且它提供了重要信息，如果您花时间仔细阅读它，它将帮助您追踪代码中的错误。

那么让我们看看它的内容：

Exception in thread "main" java.lang.NullPointerException

堆栈跟踪的第一行告诉您许多事情：

• 它告诉您抛出异常的 Java 线程的名称。对于一个只有一个线程的简单程序（就像这个），它将是“main”。让我们继续...
• 它告诉您抛出的异常的全名；即java.lang.NullPointerException。
• 如果异常有关联的错误消息，则会在异常名称之后输出。 NullPointerException 在这方面很不寻常，因为它很少有错误消息。

第二行是诊断 NPE 时最重要的一行。

at Test.main(Test.java:4)

这告诉我们很多事情：

• “at Test.main”表示我们位于 Test 类的 main 方法中。
• “Test.java:4”给出了类的源文件名，它告诉我们发生这种情况的语句位于文件的第 4 行。

如果您计算上面文件中的行数，就会发现第 4 行是我用“HERE”注释标记的行。

请注意，在更复杂的示例中，NPE 堆栈跟踪中会有很多行。但您可以确定第二行（第一个“at”行）会告诉您 NPE 被抛出的位置¹。

简而言之，堆栈跟踪将明确告诉我们程序的哪条语句引发了 NPE。

另请参阅：什么是堆栈跟踪，以及如何使用它来调试应用程序错误？

^{1 -不完全正确。有一些东西叫做嵌套异常...}

问题：如何在代码中查找 NPE 异常的原因？

这是最难的部分。简而言之，就是对堆栈跟踪、源代码和相关 API 文档提供的证据进行逻辑推理。

让我们首先用简单的例子（上面）来说明。我们首先查看堆栈跟踪告诉我们 NPE 发生位置的行：

int length = foo.length(); // HERE

这怎么会引发 NPE？

事实上，只有一种方法：只有当 foo 的值为 null 时才会发生这种情况。然后，我们尝试在 null 上运行 length() 方法，然后……砰！

但是（我听到你说）如果 NPE 被抛出到 length() 方法调用中怎么办？

好吧，如果发生这种情况，堆栈跟踪看起来会有所不同。第一个“at”行表示异常是在 java.lang.String 类中的某些行中引发的，而 Test.java 的第 4 行将是第二个“于”行。

那么这个 null 从哪里来呢？在这种情况下，这是显而易见的，我们需要做什么来解决它也是显而易见的。 （为 foo 分配一个非空值。）

好的，让我们尝试一个稍微棘手的示例。这将需要一些逻辑推论。

public class Test {

    private static String[] foo = new String[2];

    private static int test(String[] bar, int pos) {
        return bar[pos].length();
    }

    public static void main(String[] args) {
        int length = test(foo, 1);
    }
}

$ javac Test.java 
$ java Test
Exception in thread "main" java.lang.NullPointerException
    at Test.test(Test.java:6)
    at Test.main(Test.java:10)
$ 

所以现在我们有两条“at”行。第一个是针对这一行的：

return args[pos].length();

第二个是针对这一行的：

int length = test(foo, 1);
    

看第一行，怎么会抛出 NPE？有两种方法：

• 如果 bar 的值为 null，则 bar[pos] 将抛出 NPE。
• 如果 bar[pos] 的值为 null，则对其调用 length() 将抛出 NPE。

接下来，我们需要弄清楚哪些场景可以解释实际发生的情况。我们将从探索第一个开始：

bar 从哪里来？它是 test 方法调用的一个参数，如果我们看看 test 是如何调用的，我们可以看到它来自 foo静态变量。此外，我们可以清楚地看到，我们将 foo 初始化为非空值。这足以暂时驳回这种解释。 （理论上，其他东西可能将 foo 更改为 null ...但这并没有发生在这里。）

那么我们的第二种情况呢？好吧，我们可以看到 pos 是 1，所以这意味着 foo[1] 必须是 null。这可能吗？

确实如此！这就是问题所在。当我们这样初始化时：

private static String[] foo = new String[2];

我们分配一个 String[] ，其中两个元素 被初始化为 null。之后，我们没有更改 foo 的内容...因此 foo[1] 仍将为 null。

那么在安卓上呢？

在 Android 上，追踪 NPE 的直接原因要简单一些。异常消息通常会告诉您正在使用的空引用的（编译时）类型以及抛出 NPE 时尝试调用的方法。这简化了查明直接原因的过程。

但另一方面，Android 有一些导致 NPE 的常见平台特定原因。一种非常常见的情况是 getViewById 意外返回 null。我的建议是搜索有关意外 null 返回值的原因的问答。

Answer 5

这就像您正在尝试访问一个 null 的对象。考虑下面的例子：

TypeA objA;

此时您刚刚声明这个对象，但还没有初始化或实例化。每当您尝试访问其中的任何属性或方法时，它都会抛出 NullPointerException ，这是有道理的。

另请参阅下面的示例：

String a = null;
System.out.println(a.toString()); // NullPointerException will be thrown

Answer 6

当应用程序在需要对象的情况下尝试使用 null 时，会引发空指针异常。其中包括：

1. 调用 null 对象的实例方法。
2. 访问或修改 null 对象的字段。
3. 将 null 的长度视为数组。
4. 访问或修改 null 的槽，就像它是一个数组一样。
5. 抛出 null 就好像它是 Throwable 值一样。

应用程序应该抛出此类的实例来指示 null 对象的其他非法使用。

参考： http://docs.oracle.com/javase /8/docs/api/java/lang/NullPointerException.html

Answer 7

null 指针是指向任何地方的指针。当您取消引用指针 p 时，您会说“给我存储在“p”中的位置处的数据。当 p 是 null 指针时，p中存储的位置是nowhere，你是说“给我'nowhere'位置的数据”，显然，它不能这样做，所以。它抛出一个空指针异常

。一般来说，这是因为某些东西没有正确初始化。

Answer 8

已经有很多解释来解释它是如何发生以及如何修复它，但您还应该遵循最佳实践以避免NullPointerException 根本没有。

参见：
一个很好的列表最佳实践

我想补充一点，充分利用 final 修饰符。
在 Java 中适用时使用“final”修饰符

摘要：

1. 使用final修饰符来强制执行良好的初始化。
2. 避免在方法中返回 null，例如在适用时返回空集合。
3. 使用注释 @NotNull和<一个href="https://javadoc.io/static/com.github.spotbugs/spotbugs-annotations/3.1.12/edu/umd/cs/findbugs/annotations/Nullable.html" rel="noreferrer"><代码> @Nullable
4. 快速失败并使用断言来避免 null 对象在不应该为 null 时在整个应用程序中传播。
5. 首先对已知对象使用 equals：if("knownObject".equals(unknownObject)
6. 优先使用 valueOf() 而不是 toString()。
7. 使用 null安全 StringUtils方法StringUtils.isEmpty(null)
8. 使用Java 8Optional作为方法中的返回值，Optional类提供了一种表示的解决方案 。可选值而不是空引用。

Answer 9

空指针异常表明您正在使用对象但未对其进行初始化。

例如，下面是一个学生类，它将在我们的代码中使用它。

public class Student {

    private int id;

    public int getId() {
        return this.id;
    }

    public setId(int newId) {
        this.id = newId;
    }
}

下面的代码给你一个空指针异常。

public class School {

    Student student;

    public School() {
        try {
            student.getId();
        }
        catch(Exception e) {
            System.out.println("Null pointer exception");
        }
    }
}

因为您正在使用 student，但您忘记了像中那样初始化它
正确代码如下所示：

public class School {

    Student student;

    public School() {
        try {
            student = new Student();
            student.setId(12);
            student.getId();
        }
        catch(Exception e) {
            System.out.println("Null pointer exception");
        }
    }
}

Answer 10

在Java中，一切（不包括原始类型）都是类的形式。

如果您想使用任何对象，则有两个阶段：

1. 声明
2. 初始化

示例：

• 声明：Object object;
• 初始化：object = new Object();

与数组概念相同：

• 声明： Item item[] = new Item[5];
• 初始化：item[0] = new Item();

如果您没有给出初始化部分，则出现 NullPointerException 。

Answer 11

在 Java 中，您声明的所有变量实际上都是对对象的“引用”（或原语）而不是对象本身。

当您尝试执行一个对象方法时，引用会要求活动对象执行该方法。但如果引用引用的是 NULL（无、零、void、nada），那么该方法就无法执行。然后运行时通过抛出 NullPointerException 来让您知道这一点。

您的引用“指向” null，因此“Null -> Pointer”。

该对象位于 VM 内存空间中，访问它的唯一方法是使用 this 引用。举个例子：

public class Some {
    private int id;
    public int getId(){
        return this.id;
    }
    public setId( int newId ) {
        this.id = newId;
    }
}

在代码中的另一个地方：

Some reference = new Some();    // Point to a new object of type Some()
Some otherReference = null;     // Initiallly this points to NULL

reference.setId( 1 );           // Execute setId method, now private var id is 1

System.out.println( reference.getId() ); // Prints 1 to the console

otherReference = reference      // Now they both point to the only object.

reference = null;               // "reference" now point to null.

// But "otherReference" still point to the "real" object so this print 1 too...
System.out.println( otherReference.getId() );

// Guess what will happen
System.out.println( reference.getId() ); // :S Throws NullPointerException because "reference" is pointing to NULL remember...

这是一件需要知道的重要事情 - 当不再有对对象的引用时（在上面的示例中，当 reference 和 otherReference 都指向 null）则该对象“无法访问”。我们无法使用它，因此该对象已准备好被垃圾收集，并且在某个时刻，VM 将释放该对象使用的内存并分配另一个对象。

Answer 12

另一种 NullPointerException 情况发生在声明一个对象数组，然后立即尝试取消引用其中的元素时。

String[] phrases = new String[10];
String keyPhrase = "Bird";
for(String phrase : phrases) {
    System.out.println(phrase.equals(keyPhrase));
}

^{如果颠倒比较顺序，就可以避免这种特定的 NPE；即，在保证非空对象上使用 .equals。}

数组内的所有元素 初始化为其共同的初始值；对于任何类型的对象数组，这意味着所有元素均为 null。

在访问或取消引用数组中的元素之前，您必须先初始化它们。

String[] phrases = new String[] {"The bird", "A bird", "My bird", "Bird"};
String keyPhrase = "Bird";
for(String phrase : phrases) {
    System.out.println(phrase.equals(keyPhrase));
}