【Java基础——13 数组】

在 Java 中，数组是一种用于存储固定大小的同类型元素的容器。它是一个对象，具有一些固有的特性和操作方法。数组可以是基本类型的数组（如 int、char）或引用类型的数组（如对象）。

一维数组：定义和初始化

public class ArrayExample {
    public static void main(String[] args) {
        // 定义数组
        int[] intArray; // 声明数组
        intArray = new int[5]; // 分配内存

        // 初始化数组
        intArray[0] = 1;
        intArray[1] = 2;
        intArray[2] = 3;
        intArray[3] = 4;
        intArray[4] = 5;

        // 直接初始化
        int[] anotherArray = {1, 2, 3, 4, 5};

        // 访问和打印数组元素
        for (int i = 0; i < intArray.length; i++) {
            System.out.println("Element at index " + i + ": " + intArray[i]);
        }
    }
}

二维数组:  定义和初始化

public class MultiDimensionalArrayExample {
    public static void main(String[] args) {
        // 定义二维数组
        int[][] matrix = new int[3][4]; // 3行4列的二维数组

        // 初始化二维数组
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 4; j++) {
                matrix[i][j] = i + j;
            }
        }

        // 直接初始化
        int[][] anotherMatrix = {
            {1, 2, 3, 4},
            {5, 6, 7, 8},
            {9, 10, 11, 12}
        };

        // 访问和打印二维数组元素
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.println("Element at index [" + i + "][" + j + "]: " + matrix[i][j]);
            }
        }
    }
}

数组常用操作

数组复制

public class ArrayCopyExample {
    public static void main(String[] args) {
        int[] sourceArray = {1, 2, 3, 4, 5};
        int[] destinationArray = new int[sourceArray.length];

        // 使用 System.arraycopy() 复制数组
        System.arraycopy(sourceArray, 0, destinationArray, 0, sourceArray.length);

        // 打印复制后的数组
        for (int i : destinationArray) {
            System.out.println(i);
        }
    }
}

在 Java 中，数组的初始化方法有三种：默认初始化、静态初始化和动态初始化。

1. 默认初始化

Java 会为数组中的每个元素提供默认值。这种方式只需要声明数组，并为其分配内存空间，而无需显式初始化数组的每个元素。

2. 静态初始化

静态初始化在声明数组的同时显式地为每个元素赋值。这种方式适用于在创建数组时就知道所有元素值的情况。

3. 动态初始化

动态初始化先声明数组并分配内存空间，然后在代码中逐个元素赋值。适用于在运行时计算或获取数组元素值的情况。

public class ArrayInitializationExample {
    public static void main(String[] args) {
        // 默认初始化
        int[] defaultArray = new int[3];
        System.out.println("Default initialized array:");
        for (int i = 0; i < defaultArray.length; i++) {
            System.out.println("Element at index " + i + ": " + defaultArray[i]);
        }

        // 静态初始化
        int[] staticArray = {10, 20, 30};
        System.out.println("\nStatic initialized array:");
        for (int i = 0; i < staticArray.length; i++) {
            System.out.println("Element at index " + i + ": " + staticArray[i]);
        }

        // 动态初始化
        int[] dynamicArray = new int[3];
        for (int i = 0; i < dynamicArray.length; i++) {
            dynamicArray[i] = i + 1;
        }
        System.out.println("\nDynamic initialized array:");
        for (int i = 0; i < dynamicArray.length; i++) {
            System.out.println("Element at index " + i + ": " + dynamicArray[i]);
        }
    }
}

下标越界（Array Index Out of Bounds）

在 Java 中，数组的下标越界（Array Index Out of Bounds）是一个常见的运行时错误。当尝试访问数组中不存在的元素时，Java 会抛出 ArrayIndexOutOfBoundsException 异常。

产生原因

1. 负索引：尝试使用负数作为数组索引。
2. 超出索引范围：尝试使用大于或等于数组长度的索引。

预防措施

1. 检查数组长度：在访问数组元素之前，始终检查索引是否在有效范围内。
2. 使用增强的 for 循环：增强的 for 循环不会直接使用索引，减少了下标越界的风险。
3. 避免硬编码索引：使用变量或常量来表示索引，减少手动输入索引时出错的可能性。

错误处理

通过捕获 ArrayIndexOutOfBoundsException 异常，可以使程序在发生错误时处理异常，而不是直接崩溃。