Java 数组全解析_java {"7","8","12","16"} 解析

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

Java 数组的基础知识：

1. 声明数组

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

type[] name = new type[length];
1

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

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

int[] intArray = new int[10];
1

2. 初始化数组

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

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

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

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

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

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

type[] name = new type[length];
1

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

float[] floatArray = new float[5];
1

3. 访问数组元素

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

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

int value = intArray[2];
1

4. 数组长度

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

int length = intArray.length;
1

Java 数组的相关原理：

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

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

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

Java 数组的应用：

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

1. 存储和操作数据集合

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

2. 排序和查找算法

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

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

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

Java 数组的示例代码：

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

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

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

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
2
3
4
5
6
7

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

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
2
3
4
5
6
7
8
9
10
11
12

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

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
2
3
4
5
6
7
8
9

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

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

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

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

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
2
3
4
5

8. 对象型数组的应用

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

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
2
3
4
5
6
7
8
9
10

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

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
2
3
4
5
6
7
8
9
10
11
12
13
14

10. 多维数组的应用

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

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();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18