#include<GUIQU.h>
int main {
上期回顾:【Java笔记】第5章：函数
个人主页：C_GUIQU
归属专栏：【Java学习】
return 一键三连;
}
前言
各位小伙伴大家好！上期小编给大家讲解了Java中的函数，接下来讲讲数组！
1. 数组概括
在Java中，数组是一种用于存储多个相同类型数据的集合。数组在内存中占据连续的空间，每个元素都可以通过索引来访问。
【数组的概念】
- 索引（或下标）：Java中的数组索引从0开始，这意味着第一个元素的索引是0，第二个元素的索引是1，依此类推。
- 长度：数组的长度是数组中元素的数量，这个信息可以通过数组的
length属性获得。 - 元素：数组中的单个数据项称为元素，每个元素都可以通过其索引来访问。
- 多维数组：Java支持多维数组，即数组的数组。例如，一个二维数组可以看作是一行行的数组。
【数组的性质】
- 类型安全：Java数组是类型安全的，这意味着一个数组只能包含特定类型的元素。例如，一个
int类型的数组只能包含int类型的元素。 - 固定长度：在Java中，一旦数组被创建，其长度就固定不变。如果需要改变数组的长度，必须创建一个新的数组并将原数组的内容复制过去。
- 连续内存分配：Java数组中的所有元素都存储在连续的内存块中，这有助于提高访问效率。
- 默认初始化：Java中的数组在创建时会自动初始化。例如，整型数组默认初始化为0，对象数组默认初始化为
null。 - 遍历和访问：可以使用for循环、while循环或do-while循环遍历数组元素。也可以通过索引直接访问数组中的特定元素。
【创建数组】
在Java中，可以使用以下方式创建数组：
// 创建一个包含10个整数的数组
int[] numbers = new int[10];
// 创建一个并初始化一个字符串数组
String[] names = {"Alice", "Bob", "Charlie"};
// 创建一个二维数组
int[][] matrix = new int[3][4];
【访问和修改数组元素】
// 访问第一个元素
int firstElement = numbers[0];
// 修改第三个元素
numbers[2] = 50;
// 输出数组长度
System.out.println("数组长度：" + numbers.length);
【 数组操作】
Java提供了Arrays类，该类包含了许多用于操作数组的静态方法，如排序、搜索、填充和复制等。
import java.util.Arrays;
// 对数组进行排序
Arrays.sort(numbers);
// 在数组中搜索元素
int index = Arrays.binarySearch(numbers, 50);
// 填充数组
Arrays.fill(numbers, 10);
【注意事项】
- Java数组在创建时必须指定类型，不能像某些动态语言那样存储不同类型的元素。
- 数组是引用类型，当将一个数组赋值给另一个数组时，实际上是将引用赋值，两个数组变量将指向同一块内存空间。
- 数组可以存储基本数据类型值，也可以存储对象引用，但不能直接存储对象本身。
Java数组是编程中非常基础且重要的数据结构，理解和掌握数组的这些概念和性质对于Java编程至关重要。
2. 数组的内存
在Java中，数组是一种引用数据类型，用于存储多个相同数据类型的元素。
Java中的数组内存分配可以分为两个部分：数组引用的存储和数组元素的存储。
- 数组引用的存储：数组引用是一个变量，存储在栈内存（Stack）中。当声明一个数组时，比如
int[] arr;，这时只是在栈上分配了一个引用变量arr，这个变量此时并没有指向任何实际的数组对象。 - 数组元素的存储：实际的数组元素存储在堆内存（Heap）中。当使用
new关键字创建数组时，如arr = new int[10];，会在堆上分配足够的空间来存储数组元素，并且栈上的数组引用arr指向这个堆内存中的数组。
在Java中，数组的创建是动态的，即数组的大小在运行时确定。一旦数组被创建，其大小就固定了，不能动态改变。
数组初始化：
- 静态初始化：在声明数组的同时初始化数组元素，例如
int[] arr = {1, 2, 3};。 - 动态初始化：在声明数组后，通过分配空间的方式进行初始化，例如
int[] arr = new int[3];，此时数组元素会自动初始化为该数据类型的默认值（如整型为0，布尔型为false等）。
数组的访问：
Java中的数组是通过索引来访问的，索引从0开始。例如，arr[0] 表示访问数组 arr 的第一个元素。
数组的遍历：
可以使用for循环或者增强for循环（foreach循环）来遍历数组。
数组的默认值：
- 整型数组元素的默认值为0。
- 浮点型数组元素的默认值为0.0。
- 字符型数组元素的默认值为’\u0000’。
- 布尔型数组元素的默认值为false。
- 引用类型数组元素的默认值为null。
注意事项：
- 数组是对象，所以在使用前必须初始化。
- 数组一旦创建，其长度就固定不变。
- 数组可以存储基本数据类型值，也可以存储对象引用。
- 数组也是一种数据结构，可以用来实现复杂的数据处理逻辑，如数组列表（ArrayList）、数组队列（ArrayDeque）等。
3. 数组扩容
在Java中，数组一旦创建，其大小就固定不变。这意味着如果你创建了一个长度为10的数组，你就不能直接将其大小增加到20。如果你需要更大的数组，你必须创建一个新数组，然后将原数组的内容复制到新数组中。这个过程通常称为“数组扩容”。
以下是一个简单的数组扩容示例：
public class ArrayExpansion {
public static void main(String[] args) {
int[] originalArray = {1, 2, 3, 4, 5}; // 创建一个初始数组
int newLength = originalArray.length * 2; // 新数组的长度是原数组长度的两倍
// 创建一个新数组，长度是原数组长度两倍
int[] newArray = new int[newLength];
// 将原数组的内容复制到新数组中
for (int i = 0; i < originalArray.length; i++) {
newArray[i] = originalArray[i];
}
// newArray现在就是扩容后的数组
// 如果需要，可以继续向newArray中添加新元素
}
}
在这个例子中，我们首先创建了一个长度为5的数组 originalArray。然后，我们创建了一个新数组 newArray，其长度是原数组长度的两倍。接着，我们使用一个for循环将 originalArray 中的所有元素复制到 newArray 中。现在，newArray 就是一个长度为10的数组，前5个元素与 originalArray 相同，后5个元素为默认值（对于整型数组，默认值为0）。
这种方法虽然可以实现数组扩容，但效率并不高，因为涉及到数组的复制。在实际应用中，如果需要频繁地对数组进行扩容，通常会使用一些动态数据结构，如 ArrayList，它内部会自动处理数组的扩容问题，并提供更高效的添加和删除元素的操作。
4. 二维数组
在Java中，二维数组是数组的数组，即一个一维数组的每个元素都是一个一维数组。二维数组可以看作是一个表格，有行和列。在内存中，二维数组可以看作是数组的数组，或者是一维数组的嵌套。
二维数组的声明和初始化：
-
静态初始化：
int[][] myArray = { {1, 2, 3}, // 第一行 {4, 5, 6}, // 第二行 {7, 8, 9} // 第三行 }; -
动态初始化：
int rows = 3; int cols = 4; int[][] myArray = new int[rows][cols]; // 创建一个3行4列的二维数组在动态初始化的情况下，每个一维数组默认初始化为其元素类型的默认值（例如，整型为0，布尔型为false等）。
访问二维数组的元素：
二维数组的元素通过行索引和列索引来访问。例如，要访问上面静态初始化的二维数组中的元素5，可以使用 myArray[1][1]，其中 1 是行索引，1 是列索引。
遍历二维数组：
可以使用嵌套的for循环来遍历二维数组的所有元素：
for (int i = 0; i < myArray.length; i++) { // 遍历行
for (int j = 0; j < myArray[i].length; j++) { // 遍历列
System.out.print(myArray[i][j] + " "); // 访问和打印元素
}
System.out.println(); // 换行
}
注意事项：
- Java中的二维数组不必是规则的，即每一行的列数可以不同。
- 二维数组的每一行实际上是一个一维数组，因此每一行的大小可以单独分配。
- 二维数组的内存分配是在堆上进行的，而数组的引用存储在栈上。
- 二维数组的创建和初始化也可以分开进行，先创建数组的引用，然后再为每一行分配空间。
5. 数组的排序
在Java中，数组排序是一个常见的操作，可以通过多种方式实现。以下是一些常用的数组排序方法：
- 使用Java标准库的排序方法：
Java的Arrays类提供了一个sort方法，可以用来对数组进行排序。这是最简单和最直接的方法。
对于对象数组，int[] numbers = {3, 1, 4, 1, 5, 9}; Arrays.sort(numbers);sort方法会使用元素的compareTo方法（如果对象实现了Comparable接口）来进行排序。 - 使用冒泡排序算法：
冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。public static void bubbleSort(int[] arr) { int n = arr.length; for (int i = 0; i < n - 1; i++) { for (int j = 0; j < n - i - 1; j++) { if (arr[j] > arr[j + 1]) { // 交换 arr[j+1] 和 arr[j] int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } } - 使用快速排序算法：
快速排序是一种更高效的排序算法，它使用分治法策略来把一个序列分为较小的序列，在递归中分别对它们进行排序。public static void quickSort(int[] arr, int low, int high) { if (low < high) { // 找到基准值的位置 int pivotIndex = partition(arr, low, high); // 分别对基准值左侧和右侧的数组进行快速排序 quickSort(arr, low, pivotIndex - 1); quickSort(arr, pivotIndex + 1, high); } } public static int partition(int[] arr, int low, int high) { // 选择最后一个元素作为基准值 int pivot = arr[high]; int i = (low - 1); for (int j = low; j < high; j++) { // 如果当前元素小于或等于基准值 if (arr[j] <= pivot) { i++; // 交换 arr[i] 和 arr[j] int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } // 交换 arr[i+1] 和 arr[high]（基准值） int temp = arr[i + 1]; arr[i + 1] = arr[high]; arr[high] = temp; return i + 1; } - 使用归并排序算法：
归并排序是另一种高效的排序算法，它也是一种分治算法，将数组分成若干个小数组，对每个小数组进行排序，然后将小数组合并成较大的数组。public static void mergeSort(int[] arr, int left, int right) { if (left < right) { // 找到中间索引 int mid = left + (right - left) / 2; // 对左半边进行归并排序 mergeSort(arr, left, mid); // 对右半边进行归并排序 mergeSort(arr, mid + 1, right); // 合并两个有序数组 merge(arr, left, mid, right); } } public static void merge(int[] arr, int left, int mid, int right) { // 计算两个子数组的长度 int n1 = mid - left + 1; int n2 = right - mid; // 创建临时数组 int[] L = new int[n1]; int[] R = new int[n2]; // 将数据拷贝到临时数组中 System.arraycopy(arr, left, L, 0, n1); System.arraycopy(arr, mid + 1, R, 0, n2); // 合并临时数组 int i = 0, j = 0; // 初始索引为left int k = left; while (i < n1 && j < n2) { if (L[i] <= R[j]) { arr[k] = L[i]; i++; } else { arr[k] = R[j]; j++; } k++; } // 拷贝L[]剩余的元素 while (i < n1) { arr[k] = L[i];
结语
至此，Java数组讲解完毕。
感谢您的观看！互三必回！持续更新中~！
587
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
