JAVA基础 - 数组

目录

一. 简介

二. 一维数组

三. 二维数组

四. 不规则数组

五. 总结

---

---

一. 简介

数组是 Java 中用于存储多个相同类型元素的一种数据结构。它具有以下特点：

特性一：固定大小

数组在创建时就必须指定其长度，并且这个长度在后续不能更改。

特性二：相同数据类型

数组中的元素必须具有相同的数据类型。

特性三：连续存储

数组中的元素在内存中是连续存储的，这使得通过下标访问元素的速度非常快。

下标

数组的下标从 0 开始，依次递增。通过下标可以方便地访问和操作数组中的元素。

例如，对于一个整数数组 int[] arr = {10, 20, 30, 40, 50}; ：

• arr[0] 表示第一个元素，即 10 。
• arr[1] 表示第二个元素，即 20 ，以此类推。

如果尝试访问超出数组长度的下标，例如 arr[5] （假设数组长度为 5），将会导致运行时错误 ArrayIndexOutOfBoundsException 。

二. 一维数组

声明一维数组

可以使用以下两种方式声明一维数组：

int[] array1;
int array2[];

创建并初始化一维数组

有以下几种常见的方式：

1. 先声明，再创建并初始化：

int[] array;
array = new int[]{1, 2, 3, 4, 5};

1. 声明并创建同时初始化：

int[] array = {6, 7, 8, 9, 10};

1. 指定长度并初始化：

int[] array = new int[5];  // 创建一个长度为 5 的整数数组，初始值为 0

访问一维数组元素

通过数组的下标（索引）来访问元素，下标从 0 开始，到 数组长度 - 1 结束。

int[] array = {11, 12, 13, 14, 15};
System.out.println(array[0]);  // 输出 11

遍历一维数组

可以使用 for 循环来遍历数组：

for (int i = 0; i < array.length; i++) {
    System.out.println(array[i]);
}

或者使用增强型 for 循环（for-each 循环）：

for (int element : array) {
    System.out.println(element);
}

数组的复制

可以通过循环逐个元素复制，或者使用 System.arraycopy() 方法来实现数组的复制。

数组的排序

可以使用 Arrays.sort() 方法对数组进行排序。

以下是一个完整的示例代码，展示了一维数组的常见操作：

import java.util.Arrays;

public class OneDimensionalArrayExample {
    public static void main(String[] args) {
        // 声明并初始化数组
        int[] numbers = {9, 3, 7, 1, 5};

        // 访问数组元素
        System.out.println("第一个元素: " + numbers[0]);

        // 遍历数组
        System.out.println("数组元素: ");
        for (int i = 0; i < numbers.length; i++) {
            System.out.print(numbers[i] + " ");
        }
        System.out.println();

        // 排序数组
        Arrays.sort(numbers);

        // 再次遍历排序后的数组
        System.out.println("排序后的数组元素: ");
        for (int num : numbers) {
            System.out.print(num + " ");
        }
    }
}

三. 二维数组

声明二维数组

以下是两种常见的声明方式：

int[][] array1;
int array2[][];

创建二维数组

1. 先声明，后创建并初始化：

int[][] array;
array = new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

1. 声明并创建同时初始化：

int[][] array = {{10, 20, 30}, {40, 50, 60}};

1. 指定行数和列数进行创建：

int[][] array = new int[3][4];  // 创建一个 3 行 4 列的二维数组，初始值为 0

访问二维数组元素

通过行下标和列下标来访问元素。

int[][] array = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
System.out.println(array[1][2]);  // 输出 6

遍历二维数组

可以使用嵌套的 for 循环来遍历。

for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array[i].length; j++) {
        System.out.print(array[i][j] + " ");
    }
    System.out.println();
}

以下是一个完整的二维数组示例代码：

public class TwoDimensionalArrayExample {
    public static void main(String[] args) {
        // 声明并初始化二维数组
        int[][] numbers = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

        // 访问元素
        System.out.println("第一行第二列的元素: " + numbers[0][1]);

        // 遍历二维数组
        System.out.println("数组元素: ");
        for (int i = 0; i < numbers.length; i++) {
            for (int j = 0; j < numbers[i].length; j++) {
                System.out.print(numbers[i][j] + " ");
            }
            System.out.println();
        }
    }
}

四. 不规则数组

在 Java 中，不规则数组（也称为锯齿形数组）是指数组的每个元素本身又是一个数组，但这些子数组的长度可以不同。

以下是创建和使用不规则数组的示例：

public class JaggedArrayExample {
    public static void main(String[] args) {
        // 创建不规则数组
        int[][] jaggedArray = new int[3][];
        jaggedArray[0] = new int[]{1, 2, 3};
        jaggedArray[1] = new int[]{4, 5};
        jaggedArray[2] = new int[]{6, 7, 8, 9};

        // 访问和打印不规则数组的元素
        for (int i = 0; i < jaggedArray.length; i++) {
            for (int j = 0; j < jaggedArray[i].length; j++) {
                System.out.print(jaggedArray[i][j] + " ");
            }
            System.out.println();
        }
    }
}

在上述示例中，首先创建了一个二维数组，但只指定了行数，未指定列数。然后分别为每一行指定了不同长度的子数组，并进行了访问和打印。

不规则数组在某些情况下可以更灵活地适应数据的不规则结构。

五. 总结

一、数组的定义和声明

1. 可以使用以下方式声明数组：
   • int[] array;
   • int array[]; （不推荐）

二、数组的创建和初始化

1. 可以先声明，后创建并初始化，例如：

    int[] array;
    array = new int[]{1, 2, 3};

1. 也可以在声明的同时进行创建和初始化，例如：

    int[] array = {4, 5, 6};

1. 还可以指定长度来创建数组，初始值为默认值（如 0 、false 等），例如：

    int[] array = new int[5];

三、数组的特点

1. 固定大小：创建后长度不可变。
2. 相同数据类型：数组中的元素必须是相同的数据类型。
3. 连续存储：元素在内存中是连续存放的，便于通过下标快速访问。

四、访问数组元素

通过下标访问，下标从 0 开始，到 数组长度 - 1 结束。

五、数组的遍历

1. 使用普通的 for 循环：

    for (int i = 0; i < array.length; i++) {
        // 操作数组元素
    }

1. 使用增强型 for 循环（for-each 循环）：

    for (int element : array) {
        // 操作数组元素
    }

六、二维数组和不规则数组

1. 二维数组可以看作是由多个一维数组组成。

   • 声明方式：int[][] array;
   • 初始化方式与一维数组类似，可以指定元素值或指定行数和列数。

2. 不规则数组（锯齿形数组）的子数组长度可以不同。

七、数组的常见操作

1. 复制数组：可以通过循环逐个元素复制，或者使用系统提供的方法。
2. 排序数组：可以使用 Arrays.sort() 方法对数组进行排序。

总之，数组是 Java 中存储和操作一组相同类型数据的常用数据结构，但需要注意其长度固定的特点，在实际使用中根据具体需求选择合适的数组类型和操作方式。