Java新手指南从零开始学会创建数组并解决常见空指针与越界问题

什么是数组以及为什么使用它?
在Java编程中,
数组
是一种最基础且重要的数据结构,它允许你存储固定大小的同类型元素集合。想象一下,数组就像是一排整齐的储物柜,每个柜子都有一个编号(索引),你可以通过编号快速找到或修改里面的东西。
数组的主要优势包括:
高效访问
:通过索引可以在O(1)时间内直接访问任何元素
内存连续
:元素在内存中连续存储,提高缓存命中率
类型安全
:Java是强类型语言,数组可以确保所有元素都是同一类型
如何创建数组
1. 声明数组变量
在Java中,声明数组有两种主要方式:
// 方式1:先声明后初始化
int[] numbers; // 推荐写法,更清晰
int numbers2[]; // C风格,不推荐但在Java中合法

// 方式2:声明的同时初始化
int[] primes = {2, 3, 5, 7, 11};
2. 使用new关键字创建数组
当你需要动态创建数组时,使用
new
关键字:
// 创建长度为5的整数数组,所有元素默认为0
int[] scores = new int[5];

// 创建长度为3的字符串数组,所有元素默认为null
String[] names = new String[3];

// 创建长度为10的布尔数组,所有元素默认为false
boolean[] flags = new boolean[10];
3. 创建二维数组
二维数组实际上是数组的数组,非常适合表示表格数据:
// 创建3行4列的二维数组
int[][] matrix = new int[3][4];

// 创建不规则的二维数组(每行长度可以不同)
int[][] jagged = new int[3][];
jagged[0] = new int[2];
jagged[1] = new int[4];
jagged[2] = new int[3];

// 声明并初始化二维数组
int[][] grid = {
{1, 2, 3},
{4, 5},
{6, 7, 8, 9}
};
数组的基本操作
1. 访问和修改元素
int[] numbers = new int[5];

// 修改元素
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;

// 访问元素
System.out.println(numbers[0]); // 输出: 10
System.out.println(numbers[1]); // 输出: 20

// 使用循环批量操作
for (int i = 0; i < numbers.length; i++) { numbers[i] = i * 10; // 设置每个元素的值 } 2. 获取数组长度 int[] data = {1, 2, 3, 4, 5}; int length = data.length; // length是属性,不是方法 System.out.println("数组长度: " + length); // 输出: 5 // 二维数组的长度 int[][] matrix = new int[3][4]; System.out.println("行数: " + matrix.length); // 输出: 3 System.out.println("第一行的列数: " + matrix[0].length); // 输出: 4 3. 遍历数组 传统for循环 int[] numbers = {10, 20, 30, 40, 50}; for (int i = 0; i < numbers.length; i++) { System.out.println("索引 " + i + ": " + numbers[i]); } 增强for循环(for-each) int[] numbers = {10, 20, 30, 40, 50}; for (int number : numbers) { System.out.println(number); } 使用Arrays工具类 import java.util.Arrays; int[] numbers = {5, 2, 8, 1, 9}; // 打印数组内容 System.out.println(Arrays.toString(numbers)); // 输出: [5, 2, 8, 1, 9] // 排序 Arrays.sort(numbers); System.out.println(Arrays.toString(numbers)); // 输出: [1, 2, 5, 8, 9] // 二分查找(数组必须先排序) int index = Arrays.binarySearch(numbers, 5); System.out.println("5的索引: " + index); // 输出: 2 常见问题1:空指针异常(NullPointerException) 问题描述 空指针异常是Java中最常见的运行时异常之一,通常发生在试图访问或操作一个null引用时。 常见场景和解决方案 场景1:数组变量未初始化 // 错误示例 int[] numbers; // 只是声明,没有初始化 System.out.println(numbers.length); // 编译错误!变量可能未初始化 // 正确示例 int[] numbers = new int[5]; // 必须初始化 System.out.println(numbers.length); // 正常工作 场景2:数组被显式赋值为null // 错误示例 String[] names = null; System.out.println(names.length); // 运行时抛出NullPointerException // 正确示例:在使用前检查是否为null String[] names = null; if (names != null) { System.out.println(names.length); } else { System.out.println("数组未初始化"); } // 或者确保数组被正确初始化 String[] names = new String[3]; System.out.println(names.length); // 正常工作 场景3:数组元素为null // 错误示例 String[] names = new String[3]; System.out.println(names[0].length()); // 运行时抛出NullPointerException // 因为names[0]是null,不能调用null的length()方法 // 正确示例:在使用前检查元素是否为null String[] names = new String[3]; names[0] = "Alice"; if (names[0] != null) { System.out.println(names[0].length()); // 输出: 5 } // 或者使用条件运算符 int length = (names[0] != null) ? names[0].length() : 0; 场景4:方法返回null // 错误示例 public String[] getNames() { return null; // 某些情况下可能返回null } String[] names = getNames(); System.out.println(names.length); // 运行时抛出NullPointerException // 正确示例:总是检查返回值 String[] names = getNames(); if (names != null) { System.out.println(names.length); } else { // 处理null情况,比如返回默认值或抛出有意义的异常 throw new IllegalArgumentException("方法返回了空数组"); } 防御性编程技巧 // 1. 使用Optional(Java 8+) import java.util.Optional; public Optional getNames() {
return Optional.ofNullable(someCondition ? null : new String[]{“Alice”, “Bob”});
}

// 使用
getNames().ifPresent(names -> {
System.out.println(“数组长度: ” + names.length);
});

// 2. 提供默认值
public String[] getNamesOrDefault() {
String[] names = getNames();
return names != null ? names : new String[0]; // 返回空数组而不是null
}

// 3. 使用Objects.requireNonNull(Java 7+)
import java.util.Objects;

public void processArray(String[] array) {
Objects.requireNonNull(array, “数组不能为null”);
// 后续处理…
}
常见问题2:数组越界异常(ArrayIndexOutOfBoundsException)
问题描述
数组越界异常发生在试图访问数组范围之外的索引时。Java数组索引从0开始,最大索引是
length-1
。
常见场景和解决方案
场景1:循环条件错误
// 错误示例
int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i <= numbers.length; i++) { // 错误:应该是i < numbers.length System.out.println(numbers[i]); // 当i=5时抛出异常 } // 正确示例 for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } // 或者使用for-each(推荐) for (int number : numbers) { System.out.println(number); } 场景2:硬编码索引值 // 错误示例 int[] data = new int[3]; data[3] = 100; // 索引3不存在,最大索引是2 // 正确示例:总是使用length属性 int[] data = new int[3]; int lastIndex = data.length - 1; data[lastIndex] = 100; // 安全 场景3:负索引 // 错误示例 int[] numbers = {1, 2, 3}; System.out.println(numbers[-1]); // 抛出ArrayIndexOutOfBoundsException // 正确示例:确保索引非负 int index = getIndex(); if (index >= 0 && index < numbers.length) { System.out.println(numbers[index]); } else { System.out.println("索引无效"); } 场景4:二维数组越界 // 错误示例 int[][] matrix = new int[3][4]; matrix[3][0] = 10; // 行索引越界(最大索引是2) matrix[0][4] = 10; // 列索引越界(最大索引是3) // 正确示例:访问前检查边界 int row = 2; int col = 3; if (row >= 0 && row < matrix.length && col >= 0 && col < matrix[row].length) { matrix[row][col] = 10; } else { System.out.println("索引越界"); } 实用的边界检查工具方法 public class ArrayUtils { /** * 安全地获取数组元素 */ public static T safeGet(T[] array, int index, T defaultValue) {
if (array == null) {
return defaultValue;
}
if (index < 0 || index >= array.length) {
return defaultValue;
}
return array[index];
}

/**
* 安全地设置数组元素
*/
public static boolean safeSet(T[] array, int index, T value) {
if (array == null) {
return false;
}
if (index < 0 || index >= array.length) {
return false;
}
array[index] = value;
return true;
}

/**
* 检查索引是否有效
*/
public static boolean isValidIndex(int[] array, int index) {
return array != null && index >= 0 && index < array.length; } } // 使用示例 String[] names = {"Alice", "Bob", "Charlie"}; String name = ArrayUtils.safeGet(names, 5, "Unknown"); // 返回"Unknown" boolean success = ArrayUtils.safeSet(names, 1, "Robert"); // 返回true 综合示例:学生成绩管理系统 下面是一个完整的示例,展示如何安全地使用数组: import java.util.Arrays; public class GradeManager { private String[] studentNames; private int[] studentScores; public GradeManager(int classSize) { if (classSize <= 0) { throw new IllegalArgumentException("班级大小必须大于0"); } this.studentNames = new String[classSize]; this.studentScores = new int[classSize]; } // 安全地设置学生成绩 public boolean setStudent(int index, String name, int score) { // 检查数组是否初始化 if (studentNames == null || studentScores == null) { System.err.println("错误:数组未初始化"); return false; } // 检查索引边界 if (index < 0 || index >= studentNames.length) {
System.err.println(“错误:索引 ” + index + ” 超出范围 [0, ” + (studentNames.length-1) + “]”);
return false;
}

// 检查输入参数
if (name == null || name.trim().isEmpty()) {
System.err.println(“错误:学生姓名不能为空”);
return false;
}

if (score < 0 || score > 100) {
System.err.println(“错误:成绩必须在0-100之间”);
return false;
}

studentNames[index] = name;
studentScores[index] = score;
return true;
}

// 安全地获取学生成绩
public String getStudentInfo(int index) {
// 检查数组和索引
if (studentNames == null || studentScores == null) {
return “错误:系统未初始化”;
}

if (index < 0 || index >= studentNames.length) {
return “错误:索引 ” + index + ” 无效”;
}

// 检查元素是否为null
String name = studentNames[index];
if (name == null) {
return “索引 ” + index + “: 该位置无学生信息”;
}

int score = studentScores[index];
return String.format(“索引 %d: %s – 成绩: %d”, index, name, score);
}

// 计算平均分(跳过null元素)
public double calculateAverage() {
if (studentScores == null || studentScores.length == 0) {
return 0.0;
}

int sum = 0;
int count = 0;
for (int i = 0; i < studentScores.length; i++) { if (studentNames[i] != null) { // 只计算已设置的学生 sum += studentScores[i]; count++; } } return count == 0 ? 0.0 : (double) sum / count; } // 显示所有学生信息 public void displayAllStudents() { if (studentNames == null) { System.out.println("系统未初始化"); return; } System.out.println("=== 学生成绩表 ==="); for (int i = 0; i < studentNames.length; i++) { System.out.println(getStudentInfo(i)); } System.out.println("平均分: " + calculateAverage()); } public static void main(String[] args) { GradeManager manager = new GradeManager(3); // 安全地设置数据 manager.setStudent(0, "张三", 85); manager.setStudent(1, "李四", 92); manager.setStudent(2, "王五", 78); // 尝试越界操作(会被安全处理) manager.setStudent(3, "赵六", 88); // 索引越界,返回false // 显示所有信息 manager.displayAllStudents(); // 安全地获取单个学生信息 System.out.println("\n获取索引1的学生: " + manager.getStudentInfo(1)); System.out.println("获取索引5的学生: " + manager.getStudentInfo(5)); // 越界检查 } } 最佳实践总结 1. 防御性编程原则 总是检查null :在访问数组或数组元素前,验证它们不为null 验证边界 :确保索引在[0, length-1]范围内 使用工具方法 :创建通用的工具方法来处理常见操作 2. 代码可读性 使用有意义的变量名 :如 studentNames 而不是 arr1 添加注释 :解释复杂的边界条件 使用常量 :定义数组大小等常量 3. 现代Java特性 使用Optional :避免返回null数组 使用for-each :减少索引错误的风险 使用Arrays工具类 :减少重复代码 4. 调试技巧 // 打印数组信息用于调试 public static void debugArray(int[] array) { System.out.println("数组引用: " + (array == null ? "null" : "非null")); if (array != null) { System.out.println("数组长度: " + array.length); System.out.println("数组内容: " + Arrays.toString(array)); } } // 使用示例 int[] test = null; debugArray(test); // 输出: 数组引用: null test = new int[3]; debugArray(test); // 输出: 数组引用: 非null, 数组长度: 3, 数组内容: [0, 0, 0] 通过遵循这些指导原则和实践,你可以有效地避免空指针异常和数组越界异常,编写出更健壮、更可靠的Java代码。记住,预防错误比处理错误更重要!