Java 数组全解析

妖狐艹你老母 2023-10-10 20:54 55阅读 0赞

Java 数组是一种有序、固定长度并且具有相同数据类型元素的集合，它是 Java 语言中最常用的数据结构之一。在 Java 中，数组可以是基本数据类型的数组，也可以是对象类型的数组。

### Java 数组的基础知识： ###

1.  声明数组

数组需要在声明时指定数据类型和数组名，并指定数组的长度。语法如下：

type[] name = new type[length];

其中 `type` 是数组元素的数据类型，`name` 是数组的名称，`length` 是数组的长度。

例如，声明一个整型数组 `intArray`，包含 10 个元素，代码如下：

int[] intArray = new int[10];

1.  初始化数组

数组可以通过两种方式进行初始化：静态初始化和动态初始化。

静态初始化：在声明数组时直接为数组分配和赋值。静态初始化不需要指定数组长度，系统会根据元素个数自动计算数组长度。语法如下：

type[] name = {
         value1, value2, ..., valueN };

例如，声明一个字符串数组 `strArray`，包含 3 个元素并分别赋值为 “A”、“B” 和 “C”，代码如下：

String[] strArray = {
        "A", "B", "C"};

动态初始化：在声明数组时只分配数组空间，没有指定数组内容，需要在后续步骤中为数组元素赋值。动态初始化需要指定数组长度。语法如下：

type[] name = new type[length];

例如，声明一个浮点型数组 `floatArray`，包含 5 个元素，代码如下：

float[] floatArray = new float[5];

1.  访问数组元素

数组的元素可以通过下标或索引（从0开始）进行访问和操作，例如：`array[index]`。其中，`array` 是数组名，`index` 是下标。

例如，访问整型数组 `intArray` 的第三个元素，代码如下：

int value = intArray[2];

1.  数组长度

数组的长度可以通过 `length` 属性获取。例如，获取整型数组 `intArray` 的长度，代码如下：

int length = intArray.length;

### Java 数组的相关原理： ###

Java 数组在底层是使用连续的内存存储的，所有数组元素都放在这片连续的内存中，并且每个元素占用相同的存储空间。当程序声明数组并为其分配内存时，计算机会自动为其分配一段连续的内存区域。

对于基本数据类型的数组，数组元素会按照对应数据类型的大小进行存储。例如，整型数组的每个元素都占用 4 个字节，浮点型数组的每个元素都占用 8 个字节。

对于对象类型的数组，每个数组元素存储的是对象的引用，而不是对象本身。即使是所有对象都占用相同的内存大小，仍然需要为每个对象分配独立的内存空间。因此，对象类型的数组存储的是一组对象引用，而并非实际的对象。

### Java 数组的应用： ###

Java 数组的应用非常广泛，可以用于多种场景，例如：

1.  存储和操作数据集合

使用数组可以很方便地实现对数据集合的存储和操作，包括添加、删除、修改和查询等操作。

1.  排序和查找算法

很多排序和查找算法都需要对数组进行操作，例如冒泡排序、快速排序、二分查找等。

1.  图像、音频和视频处理

图像、音频和视频信息通常以数组的形式进行存储，通过对数组的操作可以实现对这些信息的处理和编辑。

### Java 数组的示例代码： ###

1.  声明和初始化一个整型数组

int[] intArray = new int[5]; // 声明一个包含5个元素的整型数组
    // 将数组元素赋值为0
    for (int i = 0; i < intArray.length; i++) {
        
        intArray[i] = 0;
    }

1.  将整型数组按照索引逆序排列

int[] intArray = {
        1, 2, 3, 4, 5}; // 声明并初始化一个整型数组
    // 将整型数组按照索引逆序排列
    for (int i = 0, j = intArray.length - 1; i < j; i++, j--) {
        
        int temp = intArray[i];
        intArray[i] = intArray[j];
        intArray[j] = temp;
    }

1.  查找整型数组中最大值和最小值

int[] intArray = {
        1, 2, 3, 4, 5}; // 声明并初始化一个整型数组
    int max = Integer.MIN_VALUE; // 最大值初始值为负无穷
    int min = Integer.MAX_VALUE; // 最小值初始值为正无穷
    // 遍历整型数组，查找最大值和最小值
    for (int i = 0; i < intArray.length; i++) {
        
        if (intArray[i] > max) {
        
            max = intArray[i];
        }
        if (intArray[i] < min) {
        
            min = intArray[i];
        }
    }

1.  在整型数组中查找某个元素

int[] intArray = {
        1, 2, 3, 4, 5}; // 声明并初始化一个整型数组
    int target = 3; // 需要查找的目标元素
    // 遍历整型数组，查找目标元素
    for (int i = 0; i < intArray.length; i++) {
        
        if (intArray[i] == target) {
        
            System.out.println("目标元素在数组中的索引为：" + i);
            break;
        }
    }

1.  使用二分查找算法在整型数组中查找某个元素

int[] intArray = {
        1, 2, 3, 4, 5}; // 声明并初始化一个整型数组
    int target = 3; // 需要查找的目标元素
    int low = 0; // 数组下界
    int high = intArray.length - 1; // 数组上界
    // 二分查找
    while (low <= high) {
        
        int middle = (low + high) / 2;
        if (intArray[middle] == target) {
        
            System.out.println("目标元素在数组中的索引为：" + middle);
            break;
        } else if (intArray[middle] < target) {
        
            low = middle + 1;
        } else {
        
            high = middle - 1;
        }
    }

1.  声明和初始化一个字符串型数组

String[] strArray = {
        "A", "B", "C"}; // 声明并初始化一个字符串型数组

1.  声明和初始化一个对象型数组

Person[] personArray = new Person[3]; // 声明一个包含3个元素的Person对象数组
    // 初始化Person对象数组元素
    personArray[0] = new Person("Tom", 20);
    personArray[1] = new Person("John", 25);
    personArray[2] = new Person("Mary", 22);

1.  对象型数组的应用

对象型数组可以方便地存储和操作多个对象，例如存储学生信息、员工信息等等。下面是一个示例代码，声明并初始化一个存储学生信息的对象型数组：

Student[] studentArray = new Student[3]; // 声明一个包含3个元素的Student对象数组
    // 初始化Student对象数组元素
    studentArray[0] = new Student("Tom", 20, "Male");
    studentArray[1] = new Student("John", 25, "Male");
    studentArray[2] = new Student("Mary", 22, "Female");
    // 遍历Student对象数组，输出每个学生的信息
    for (int i = 0; i < studentArray.length; i++) {
        
        Student student = studentArray[i];
        System.out.println("Name: " + student.getName() + ", Age: " + student.getAge() + ", Gender: " + student.getGender());
    }

1.  多维数组的声明和初始化

Java 语言支持多维数组，即数组中包含其他数组。多维数组可以有任意多维，但每个维度的长度必须一致。下面是一个示例代码，声明并初始化一个二维整型数组：

int[][] intArray = new int[3][4]; // 声明一个包含3行4列的二维整型数组
    // 初始化二维整型数组元素
    for (int i = 0; i < intArray.length; i++) {
        
        for (int j = 0; j < intArray[i].length; j++) {
        
            intArray[i][j] = i + j;
        }
    }
    // 遍历二维整型数组，输出每个元素的值
    for (int i = 0; i < intArray.length; i++) {
        
        for (int j = 0; j < intArray[i].length; j++) {
        
            System.out.print(intArray[i][j] + "\t");
        }
        System.out.println();
    }

1.  多维数组的应用

多维数组可以应用于很多场景，例如存储和操作二维矩阵、图像处理等。下面是一个示例代码，计算并输出两个二维矩阵的乘积：

int[][] matrixA = {
        {
        1, 2}, {
        3, 4}}; // 声明并初始化一个二维整型数组
    int[][] matrixB = {
        {
        5, 6}, {
        7, 8}}; // 声明并初始化另一个二维整型数组
    int[][] matrixC = new int[2][2]; // 声明一个用于存储乘积的二维整型数组
    // 计算矩阵乘积
    for (int i = 0; i < 2; i++) {
        
        for (int j = 0; j < 2; j++) {
        
            for (int k = 0; k < 2; k++) {
        
                matrixC[i][j] += matrixA[i][k] * matrixB[k][j];
            }
        }
    }
    // 输出矩阵乘积
    for (int i = 0; i < 2; i++) {
        
        for (int j = 0; j < 2; j++) {
        
            System.out.print(matrixC[i][j] + " ");
        }
        System.out.println();
    }