8.2 数组的定义与初始化

数组的定义

在 Java 中，数组的定义有两种方式：

方式一：声明数组变量

数据类型[] 数组名;

方式二：声明数组变量（C 风格）

数据类型 数组名[];

示例：

// 声明整型数组
int[] numbers;
// 或
int numbers[];

// 声明字符串数组
String[] names;
// 或
String names[];

数组的初始化

数组的初始化有三种方式：静态初始化、动态初始化和默认初始化。

1. 静态初始化

静态初始化是在声明数组的同时为数组元素赋值。

语法：

数据类型[] 数组名 = {元素1, 元素2, 元素3, ...};

示例：

// 静态初始化整型数组
int[] numbers = {10, 20, 30, 40, 50};

// 静态初始化字符串数组
String[] names = {"Alice", "Bob", "Charlie", "David"};

// 静态初始化字符数组
char[] characters = {'a', 'b', 'c', 'd'};

// 静态初始化布尔型数组
boolean[] flags = {true, false, true, false};

2. 动态初始化

动态初始化是先声明数组，然后使用 new 关键字创建数组对象并指定长度。

语法：

数据类型[] 数组名 = new 数据类型[长度];

示例：

// 动态初始化整型数组，长度为 5
int[] numbers = new int[5];

// 动态初始化字符串数组，长度为 3
String[] names = new String[3];

// 动态初始化双精度数组，长度为 10
double[] prices = new double[10];

3. 默认初始化

当使用动态初始化创建数组时，数组元素会被自动赋予默认值。

数据类型	默认值
byte, short, int, long	0
float, double	0.0
char	'\u0000'（空字符）
boolean	false
引用类型	null

示例：

// 动态初始化整型数组，默认值为 0
int[] numbers = new int[3];
System.out.println(numbers[0]); // 输出 0
System.out.println(numbers[1]); // 输出 0
System.out.println(numbers[2]); // 输出 0

// 动态初始化布尔型数组，默认值为 false
boolean[] flags = new boolean[2];
System.out.println(flags[0]); // 输出 false
System.out.println(flags[1]); // 输出 false

// 动态初始化字符串数组，默认值为 null
String[] names = new String[2];
System.out.println(names[0]); // 输出 null
System.out.println(names[1]); // 输出 null

数组初始化的注意事项

1. 静态初始化的长度

静态初始化时，数组的长度由初始化列表中的元素个数决定，不需要显式指定长度。

// 正确：数组长度为 3
int[] numbers = {1, 2, 3};

// 错误：静态初始化时不能指定长度
// int[] numbers = new int[3]{1, 2, 3};

2. 动态初始化的长度

动态初始化时，必须显式指定数组长度，且长度必须是一个非负整数。

// 正确：指定长度为 5
int[] numbers = new int[5];

// 错误：没有指定长度
// int[] numbers = new int[];

// 错误：长度为负数
// int[] numbers = new int[-5];

3. 数组变量的赋值

数组变量是引用类型，可以将一个数组变量赋值给另一个数组变量，此时两个变量指向同一个数组对象。

int[] a = {1, 2, 3};
int[] b = a; // b 指向 a 所指向的数组

b[0] = 100; // 修改 b[0] 会同时修改 a[0]
System.out.println(a[0]); // 输出 100
System.out.println(b[0]); // 输出 100

示例：数组初始化的使用

示例 1：静态初始化与动态初始化

public class ArrayInitializationExample {
    public static void main(String[] args) {
        // 静态初始化
        int[] staticArray = {1, 2, 3, 4, 5};
        System.out.println("Static array:");
        for (int i = 0; i < staticArray.length; i++) {
            System.out.println(staticArray[i]);
        }
        
        // 动态初始化
        int[] dynamicArray = new int[5];
        // 给动态初始化的数组赋值
        for (int i = 0; i < dynamicArray.length; i++) {
            dynamicArray[i] = i + 1;
        }
        System.out.println("\nDynamic array:");
        for (int i = 0; i < dynamicArray.length; i++) {
            System.out.println(dynamicArray[i]);
        }
    }
}

示例 2：默认初始化

public class DefaultInitializationExample {
    public static void main(String[] args) {
        // 基本类型数组的默认初始化
        int[] intArray = new int[3];
        double[] doubleArray = new double[3];
        boolean[] booleanArray = new boolean[3];
        char[] charArray = new char[3];
        
        System.out.println("int array default values:");
        for (int i = 0; i < intArray.length; i++) {
            System.out.println(intArray[i]);
        }
        
        System.out.println("\ndouble array default values:");
        for (int i = 0; i < doubleArray.length; i++) {
            System.out.println(doubleArray[i]);
        }
        
        System.out.println("\nboolean array default values:");
        for (int i = 0; i < booleanArray.length; i++) {
            System.out.println(booleanArray[i]);
        }
        
        System.out.println("\nchar array default values:");
        for (int i = 0; i < charArray.length; i++) {
            System.out.println("'" + charArray[i] + "' (ASCII: " + (int) charArray[i] + ")");
        }
        
        // 引用类型数组的默认初始化
        String[] stringArray = new String[3];
        System.out.println("\nString array default values:");
        for (int i = 0; i < stringArray.length; i++) {
            System.out.println(stringArray[i]);
        }
    }
}

示例 3：数组变量的赋值

public class ArrayAssignmentExample {
    public static void main(String[] args) {
        int[] a = {1, 2, 3};
        int[] b = a; // b 指向 a 所指向的数组
        
        System.out.println("Before modification:");
        System.out.println("a[0] = " + a[0]); // 输出 1
        System.out.println("b[0] = " + b[0]); // 输出 1
        
        // 修改 b[0]
        b[0] = 100;
        
        System.out.println("\nAfter modification:");
        System.out.println("a[0] = " + a[0]); // 输出 100
        System.out.println("b[0] = " + b[0]); // 输出 100
        
        // 创建一个新的数组并赋值给 b
        b = new int[]{4, 5, 6};
        
        System.out.println("\nAfter creating new array:");
        System.out.println("a[0] = " + a[0]); // 输出 100
        System.out.println("b[0] = " + b[0]); // 输出 4
    }
}

常见问题

1. 数组索引越界

症状：运行时错误：ArrayIndexOutOfBoundsException

解决方案：确保数组索引在有效范围内（0 到 length-1）

2. 空指针异常

症状：运行时错误：NullPointerException

解决方案：确保数组已经初始化，不为 null

3. 初始化方式错误

症状：编译错误，例如：

• error: array dimension missing
• error: illegal initializer for int[]

解决方案：正确使用静态初始化和动态初始化的语法

总结

数组的定义和初始化是 Java 中使用数组的基础。数组的定义有两种方式，初始化有三种方式：

• 静态初始化：在声明数组的同时为数组元素赋值
• 动态初始化：使用 new 关键字创建数组对象并指定长度
• 默认初始化：动态初始化时，数组元素会被自动赋予默认值

在使用数组时，需要注意数组索引越界、空指针异常等问题，确保数组的正确使用。