Java类数组创建与遍历实战指南

1. 为什么需要类数组？

在Java开发中，我们经常遇到需要处理一组相同类型对象的情况。比如管理学生信息系统中所有Student对象，或者游戏开发中处理多个Enemy对象。这时候，类数组（即对象数组）就派上了大用场。

与基本数据类型数组不同，类数组存储的是对象的引用而非对象本身。这带来了几个关键特性：

• 每个数组元素实际上是指向堆内存中对象的指针
• 未初始化的元素值为null
• 数组长度固定但对象内容可变

我见过不少初学者直接这样声明：

java复制Student[] students = new Student[50];

然后就急着调用students[0].getName()，结果抛出NullPointerException。这是因为他们忽略了关键一步——数组创建后，每个元素还需要单独实例化。

2. 类数组的完整创建流程

2.1 声明与初始化

正确的类数组创建应该分三步走：

java复制// 1. 声明数组引用
Student[] students;

// 2. 初始化数组容器
students = new Student[3]; // 现在有3个null引用

// 3. 初始化每个对象元素
students[0] = new Student("张三");
students[1] = new Student("李四");
students[2] = new Student("王五");

在内存中的实际布局是这样的：

code复制栈内存           堆内存
students   →   [ref0, ref1, ref2]
                   ↓      ↓      ↓
                Student  Student  Student
                对象1    对象2    对象3

2.2 简写语法糖

Java也支持声明时直接初始化：

java复制Student[] students = {
    new Student("张三"),
    new Student("李四"),
    new Student("王五")
};

但要注意这种写法只能在声明时使用，不能用于后续重新赋值：

java复制students = {new Student("赵六")}; // 编译错误

2.3 动态初始化技巧

当数组长度需要运行时确定时，可以这样处理：

java复制Scanner scanner = new Scanner(System.in);
int count = scanner.nextInt();

Student[] students = new Student[count];
for (int i = 0; i < count; i++) {
    students[i] = new Student("学生" + (i+1));
}

重要提示：动态创建时务必检查数组长度是否为非负数，否则会抛出NegativeArraySizeException

3. 类数组遍历的四种姿势

3.1 传统for循环

最基础也是最可控的方式：

java复制for (int i = 0; i < students.length; i++) {
    if (students[i] != null) {
        System.out.println(students[i].getName());
    }
}

优势：

• 可以精确控制遍历范围
• 能直接访问索引
• 性能最优

3.2 增强for循环

Java5引入的语法糖：

java复制for (Student student : students) {
    if (student != null) {
        System.out.println(student.getName());
    }
}

注意事项：

• 无法获取当前索引
• 不能修改数组引用（但可以修改对象内容）
• 对null元素会抛出NullPointerException

3.3 Stream API遍历

Java8+推荐方式：

java复制Arrays.stream(students)
      .filter(Objects::nonNull)
      .map(Student::getName)
      .forEach(System.out::println);

优势：

• 函数式风格
• 天然支持并行处理
• 可链式操作

3.4 迭代器模式

虽然不常见，但有时也需要：

java复制Iterator<Student> iterator = Arrays.asList(students).iterator();
while (iterator.hasNext()) {
    Student student = iterator.next();
    if (student != null) {
        System.out.println(student.getName());
    }
}

适用场景：

• 需要统一处理各种集合类型时
• 需要remove操作时（数组场景不推荐）

4. 实战中的七个避坑指南

4.1 空指针防御

类数组最容易踩的坑就是NPE。推荐两种防御方式：

1. 全局null检查：

java复制for (Student student : students) {
    if (student == null) continue;
    // 业务逻辑
}

2. 使用Optional包装：

java复制Arrays.stream(students)
      .map(Optional::ofNullable)
      .filter(Optional::isPresent)
      .map(Optional::get)
      .forEach(...);

4.2 数组长度陷阱

记住这两个关键区别：

java复制Student[] students = new Student[10];
System.out.println(students.length); // 10
System.out.println(students[0].length); // 编译错误！对象没有length属性

4.3 浅拷贝的坑

这样的拷贝操作是危险的：

java复制Student[] copy = students.clone();

因为这只是复制了引用，修改copy中的对象会影响原数组。

正确深拷贝方式：

java复制Student[] deepCopy = Arrays.stream(students)
                          .map(s -> s == null ? null : new Student(s))
                          .toArray(Student[]::new);

4.4 类型安全警告

当与泛型结合时会出现警告：

java复制List<Student>[] lists = new List<Student>[10]; // 编译错误

解决方案：

java复制List<Student>[] lists = (List<Student>[])new List<?>[10];

4.5 性能优化技巧

高频访问场景可以这样优化：

java复制// 普通方式
for (Student s : students) {...}

// 优化后
Student[] localStudents = students; // 避免多次访问数组长度
int len = localStudents.length;
for (int i = 0; i < len; i++) {
    Student s = localStudents[i];
    ...
}

4.6 数组扩容方案

Java数组长度固定，扩容需要新建数组：

java复制Student[] expand(Student[] original, int newSize) {
    Student[] newArray = new Student[newSize];
    System.arraycopy(original, 0, newArray, 0, Math.min(original.length, newSize));
    return newArray;
}

4.7 对象排序处理

对类数组排序的两种方式：

1. 实现Comparable接口：

java复制class Student implements Comparable<Student> {
    @Override
    public int compareTo(Student o) {
        return this.name.compareTo(o.name);
    }
}
Arrays.sort(students);

2. 使用Comparator：

java复制Arrays.sort(students, Comparator.comparing(Student::getScore));

5. 多维类数组实战

处理矩阵式对象结构时：

java复制class Classroom {
    Student[][] seatArrangement;
    
    void init(int rows, int cols) {
        seatArrangement = new Student[rows][cols];
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                seatArrangement[i][j] = new Student();
            }
        }
    }
}

遍历多维数组推荐方式：

java复制for (Student[] row : seatArrangement) {
    for (Student student : row) {
        if (student != null) {
            System.out.println(student);
        }
    }
}

6. 与集合的性能对比

在以下场景数组更优：

• 元素数量固定且已知
• 需要极致性能（游戏开发等）
• 与底层API交互（如JNI）

而ArrayList等集合更合适：

• 需要动态扩容
• 频繁插入删除
• 需要丰富API支持

实测数据对比（100万次操作）：

7. 现代Java中的替代方案

虽然类数组是基础，但在新项目中可以考虑：

1. 记录类型（Java16+）：

java复制record StudentRecord(String name, int age) {}
StudentRecord[] records = new StudentRecord[10];

2. 不可变数组：

java复制List<Student> immutable = List.of(new Student(), new Student());

3. 类型安全的容器：

java复制var students = new ArrayList<Student>();

不过在某些底层开发中，类数组仍然是不可替代的选择。我在开发高性能计算模块时，就曾通过精心设计的对象数组结构，将处理速度提升了40%。关键是要理解每种数据结构的适用场景。