Java 数组初始化
什么是Java数组？
数组是Java中最基本的数据结构之一，用于存储相同类型的多个变量。数组提供了一种有序集合，可以通过索引访问其中的元素。在Java中，数组是一个对象，它包含了相同类型的元素，并提供了随机访问这些元素的能力。
提示
Java中的数组索引从0开始，这意味着第一个元素的索引为0，第二个元素的索引为1，以此类推。
数组的声明与初始化
在Java中初始化数组主要有三个步骤：
- 声明数组变量
- 分配数组内存空间
- 为数组元素赋值
数组声明
数组声明定义了数组的类型和变量名，但并没有实际创建数组对象。
java
// 方式1：类型[] 变量名
int[] numbers;
// 方式2：类型 变量名[]
String names[];
两种方式在功能上完全相同，但第一种方式（类型[]）是Java官方推荐的写法。
数组内存分配
声明数组后，需要为其分配内存空间：
java
// 为numbers数组分配5个整数的空间
numbers = new int[5];
// 为names数组分配3个字符串的空间
names = new String[3];
数组元素初始化
分配内存后，数组会自动用默认值初始化：
- 数值类型（byte, short, int, long, float, double）默认为0
- char类型默认为'\u0000'
- boolean类型默认为false
- 引用类型默认为null
你可以单独为每个元素赋值：
java
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;
numbers[3] = 40;
numbers[4] = 50;
names[0] = "张三";
names[1] = "李四";
names[2] = "王五";
数组初始化的简化方式
声明与分配内存合并
java
int[] scores = new int[5]; // 创建了一个包含5个整数的数组
声明、分配和赋值一步完成
java
// 静态初始化：指定数组元素的值，数组长度由元素个数决定
int[] points = {95, 85, 76, 90, 88};
// 等价于：
int[] points = new int[]{95, 85, 76, 90, 88};
警告
使用 { } 初始化时，必须在声明的同时进行，不能先声明再用此方法赋值。
java
int[] wrongExample;
wrongExample = {1, 2, 3}; // 错误！这样是不允许的
int[] rightExample;
rightExample = new int[]{1, 2, 3}; // 正确，使用new关键字
完整示例：数组初始化与使用
java
public class ArrayInitExample {
public static void main(String[] args) {
// 1. 声明、分配内存和赋值分开进行
int[] method1; // 声明
method1 = new int[3]; // 分配内存
method1[0] = 10; // 赋值
method1[1] = 20;
method1[2] = 30;
System.out.println("第一个数组的元素:");
for (int i = 0; i < method1.length; i++) {
System.out.println("method1[" + i + "] = " + method1[i]);
}
// 2. 声明和分配内存一起，赋值分开
double[] method2 = new double[4];
method2[0] = 1.1;
method2[1] = 2.2;
method2[2] = 3.3;
method2[3] = 4.4;
System.out.println("\n第二个数组的元素:");
for (double value : method2) {
System.out.println(value);
}
// 3. 声明、分配内存和赋值一步完成
String[] method3 = {"苹果", "香蕉", "橙子", "葡萄"};
System.out.println("\n第三个数组的元素:");
for (String fruit : method3) {
System.out.println(fruit);
}
}
}
输出结果：
第一个数组的元素:
method1[0] = 10
method1[1] = 20
method1[2] = 30
第二个数组的元素:
1.1
2.2
3.3
4.4
第三个数组的元素:
苹果
香蕉
橙子
葡萄
多维数组的初始化
多维数组本质上是"数组的数组"。Java支持任意维度的数组，但最常见的是二维数组。
二维数组的声明与初始化
java
// 声明一个2行3列的二维整数数组
int[][] matrix = new int[2][3];
// 分别赋值
matrix[0][0] = 1;
matrix[0][1] = 2;
matrix[0][2] = 3;
matrix[1][0] = 4;
matrix[1][1] = 5;
matrix[1][2] = 6;
// 或者使用简化方式进行初始化
int[][] quickMatrix = {
{1, 2, 3},
{4, 5, 6}
};
不规则数组（锯齿状数组）
Java允许创建每行长度不同的二维数组：
java
// 创建一个有3行的数组，但每行的列数不同
int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int[2]; // 第一行有2列
jaggedArray[1] = new int[4]; // 第二行有4列
jaggedArray[2] = new int[3]; // 第三行有3列
// 初始化元素
jaggedArray[0][0] = 1;
jaggedArray[0][1] = 2;
// ... 其他元素赋值
// 或者使用简化语法
int[][] jaggedQuick = {
{1, 2},
{3, 4, 5, 6},
{7, 8, 9}
};
实际应用案例
案例1：计算学生成绩平均分
java
public class StudentGradeAverage {
public static void main(String[] args) {
// 初始化学生成绩数组
int[] grades = {85, 92, 78, 95, 88, 90, 72, 89};
// 计算总分
int sum = 0;
for (int grade : grades) {
sum += grade;
}
// 计算平均分
double average = (double) sum / grades.length;
// 输出结果
System.out.println("学生人数: " + grades.length);
System.out.println("总分: " + sum);
System.out.println("平均分: " + average);
// 查找最高分和最低分
int highest = grades[0];
int lowest = grades[0];
for (int i = 1; i < grades.length; i++) {
if (grades[i] > highest) {
highest = grades[i];
}
if (grades[i] < lowest) {
lowest = grades[i];
}
}
System.out.println("最高分: " + highest);
System.out.println("最低分: " + lowest);
}
}
输出结果：
学生人数: 8
总分: 689
平均分: 86.125
最高分: 95
最低分: 72
案例2：商品库存管理
java
public class InventoryManager {
public static void main(String[] args) {
// 商品名称
String[] products = {"手机", "电脑", "耳机", "键盘", "鼠标"};
// 对应的库存数量
int[] inventory = {120, 85, 200, 150, 300};
// 对应的价格
double[] prices = {2999.99, 6500.00, 299.50, 159.90, 89.90};
// 显示库存报表
System.out.println("商品库存报表");
System.out.println("-------------------------------");
System.out.println("商品名称\t库存数量\t单价\t库存总值");
System.out.println("-------------------------------");
double totalValue = 0.0;
for (int i = 0; i < products.length; i++) {
double itemTotalValue = inventory[i] * prices[i];
totalValue += itemTotalValue;
System.out.printf("%s\t%d\t%.2f\t%.2f\n",
products[i], inventory[i], prices[i], itemTotalValue);
}
System.out.println("-------------------------------");
System.out.printf("库存总价值: %.2f\n", totalValue);
// 查找库存最少的商品
int minIndex = 0;
for (int i = 1; i < inventory.length; i++) {
if (inventory[i] < inventory[minIndex]) {
minIndex = i;
}
}
System.out.println("\n库存最少的商品是: " + products[minIndex] +
"，仅剩 " + inventory[minIndex] + " 件，建议补货!");
}
}
输出结果：
商品库存报表
-------------------------------
商品名称 库存数量 单价 库存总值
-------------------------------
手机 120 2999.99 359998.80
电脑 85 6500.00 552500.00
耳机 200 299.50 59900.00
键盘 150 159.90 23985.00
鼠标 300 89.90 26970.00
-------------------------------
库存总价值: 1023353.80
库存最少的商品是: 电脑，仅剩 85 件，建议补货!
数组初始化中的常见问题
1. 数组越界
当尝试访问超出数组长度范围的索引时，会抛出ArrayIndexOutOfBoundsException异常。
java
int[] numbers = new int[5]; // 索引范围是0-4
numbers[5] = 100; // 错误！会抛出ArrayIndexOutOfBoundsException
2. 忘记初始化
声明了数组但没有初始化（使用new关键字分配内存）就尝试使用，会导致NullPointerException。
java
int[] notInitialized; // 只声明，没有初始化
notInitialized[0] = 10; // 错误！会抛出NullPointerException
3. 静态初始化的限制
使用花括号进行静态初始化时，必须在声明的同时进行。
总结
Java数组初始化是Java编程的基础知识，主要包括以下几种方式：
- 分步初始化：先声明，再分配内存，最后赋值
- 部分简化：声明和分配内存同时进行，随后赋值
- 完全简化：声明、分配内存和赋值一步完成
多维数组可以看作是"数组的数组"，它们遵循相同的初始化规则，但可以创建规则或不规则（锯齿状）的结构。
理解并掌握不同的数组初始化方法，能够让你根据不同场景选择最合适的方式来处理数据集合，提高代码效率与可读性。
练习
- 创建一个包含10个整数的数组，使用三种不同的初始化方式。
- 创建一个字符串数组存储一周七天的名称，并遍历打印。
- 创建一个3×3的二维数组表示九宫格，并初始化为1-9的数字。
- 实现一个简单的学生管理系统，用数组存储学生姓名和成绩，并计算平均分、最高分和最低分。
- 创建一个不规则二维数组，其中第一行有2个元素，第二行有3个元素，第三行有4个元素，并初始化为你喜欢的数字。
备注
学习数组时，建议多动手实践不同的初始化方法，并尝试处理数组边界情况，这将有助于加深对数组操作的理解。