Java自定义类数组初始化详解：解决空指针异常

Leo

发布时间：2026-10-16 | 3人浏览过

原创

在使用Java时，创建自定义类对象组成的数组往往容易遭遇空指针异常。这是因为仅声明数组并未自动实例化其中的元素。本文将深入解析自定义类数组的初始化规则，对比基本类型与对象类型的差异，并提供一种常见的通过封装类管理数组数据的实践方案。

自定义类对象的正确初始化

初学者常遇到的困惑是：当定义一个包含自定义类的 List 集合并向其中添加多个对象时，如果使用固定大小的数组辅助填充，往往会抛出 NullPointerException。

例如，以下代码会在运行时报错：

public void addToAllCourses() {
    Course[] courses = new Course[3];
    // 报错点：courses[0] 此时仍为 null
    courses[0].setId("2");
    courses[0].setName("C语言");
}

原理解析： Java中的数组分为两种情况：一种是基础类型（如 int, String），另一种是引用类型（如自定义类）。虽然基础类型和引用类型的数组在内存中都需要分配空间，但自定义类对象的数组在声明后，内部的每一个位置默认值为 null。

因此，必须先遍历每个索引，利用关键字 new 显式创建该类的实例对象，才能调用其方法或设置属性。

第1步：逐一实例化数组元素

操作目的：确保数组内的每个引用指向实际存在的对象。
操作方式：在循环或手动赋值前，为对应下标执行 new 类名()。

修正后的完整代码如下：

Course[] courses = new Course[3];
// 必须为每个元素创建新对象
courses[0] = new Course();
courses[0].setId("2");
courses[0].setName("C语言");

courses[1] = new Course();
courses[1].setId("3");
courses[1].setName("数据库");

courses[2] = new Course();
courses[2].setId("4");
courses[2].setName("计算机网络");

// 添加到List集合
allCourses.addAll(Arrays.asList(courses));

第2步：处理二维自定义类数组

对于多维数组逻辑同样适用。在创建二维自定义类数组时，必须依次展开各个维度的实例化过程，不可省略任何层级。

// 第一步：创建二维结构
Course[][] courses = new Course[2][3];  

// 第二步：实例化一维数组并填入对象
courses[0] = new Course[3];
courses[0][0] = new Course();
courses[0][0].setId("0");
courses[0][0].setName("测试课程");
System.out.println(courses[0][0].getId()); // 正常运行

自定义类封装数组的通用实现

除了直接操作原生数组，在实际开发中，通常建议将数组进行简单的面向对象封装，提供插入、删除和查找等安全的方法。这是一种通用的数据结构教学与实践方案。

第1步：构建基础顺序数组类 (MyArray)

该类实现了基本的增删改查功能。核心逻辑在于维护一个计数器 cnt 来记录当前实际存储的元素个数，防止越界访问。

public class MyArray {
    private long[] array;
    private int cnt; // 实际存储元素计数

    public MyArray(int size) {
        array = new long[size];
    }

    // 插入数据
    public void insert(long value) {
        if (cnt < array.length) {
            array[cnt++] = value;
        }
    }

    // 显示所有数据
    public void display() {
        System.out.print("[");
        for (int i = 0; i < cnt; i++) {
            System.out.print(array[i]);
            if (i != cnt - 1) System.out.print(",");
        }
        System.out.println("]");
    }

    // 按索引查找
    public long get(int index) throws Exception {
        if (index < 0 || index >= cnt)
            throw new Exception("输入范围错误");
        return array[index];
    }

    // 按值查找（返回索引或-1）
    public int search(long targetValue) {
        int i;
        for (i = 0; i < cnt; i++) {
            if (targetValue == array[i]) break;
        }
        if (i == cnt) return -1;
        else return i;
    }

    // 按值删除（找到后整体前移覆盖）
    public boolean delete(long deleteValue) {
        int index = search(deleteValue);
        if (index == -1) return false;
        
        for (int j = index; j < cnt - 1; j++) {
            array[j] = array[j + 1];
        }
        cnt--;
        return true;
    }
}

第2步：进阶——构建有序数组类 (MyOrderArray)

如果需要保持数组内数据始终处于升序排列，只需修改 insert 方法的逻辑：寻找第一个大于目标值的索引作为插入点，并将其右侧元素全部后移。

此外，有序数组支持效率更高的**二分查找法**。该方法通过不断折半缩小查找范围，时间复杂度从线性降为对数级别。

public int binarySearch(long targetValue) {
    int low = 0;
    int top = cnt - 1; // 注意上边界调整
    while(low <= top) {
        int middle = (low + top) / 2;
        if(targetValue == array[middle]) {
            return middle;
        } else if(targetValue < array[middle]) {
            top = middle - 1;
        } else {
            low = middle + 1;
        }
    }
    return -1; // 未找到
}

通过以上两个类的演进，可以看出掌握基础的数组实例化机制是编写更复杂数据结构的基础。