【Java笔记】第6章：数组

#include<GUIQU.h>
int main {
上期回顾:【Java笔记】第5章：函数
个人主页：C_GUIQU
归属专栏：【Java学习】
return 一键三连;
}

前言

各位小伙伴大家好！上期小编给大家讲解了Java中的函数，接下来讲讲数组！

1. 数组概括

在Java中，数组是一种用于存储多个相同类型数据的集合。数组在内存中占据连续的空间，每个元素都可以通过索引来访问。

【数组的概念】

1. 索引（或下标）：Java中的数组索引从0开始，这意味着第一个元素的索引是0，第二个元素的索引是1，依此类推。
2. 长度：数组的长度是数组中元素的数量，这个信息可以通过数组的length属性获得。
3. 元素：数组中的单个数据项称为元素，每个元素都可以通过其索引来访问。
4. 多维数组：Java支持多维数组，即数组的数组。例如，一个二维数组可以看作是一行行的数组。

【数组的性质】

1. 类型安全：Java数组是类型安全的，这意味着一个数组只能包含特定类型的元素。例如，一个int类型的数组只能包含int类型的元素。
2. 固定长度：在Java中，一旦数组被创建，其长度就固定不变。如果需要改变数组的长度，必须创建一个新的数组并将原数组的内容复制过去。
3. 连续内存分配：Java数组中的所有元素都存储在连续的内存块中，这有助于提高访问效率。
4. 默认初始化：Java中的数组在创建时会自动初始化。例如，整型数组默认初始化为0，对象数组默认初始化为null。
5. 遍历和访问：可以使用for循环、while循环或do-while循环遍历数组元素。也可以通过索引直接访问数组中的特定元素。

【创建数组】
在Java中，可以使用以下方式创建数组：

// 创建一个包含10个整数的数组
int[] numbers = new int[10];
// 创建一个并初始化一个字符串数组
String[] names = {"Alice", "Bob", "Charlie"};
// 创建一个二维数组
int[][] matrix = new int[3][4];
1
2
3
4
5
6

【访问和修改数组元素】

// 访问第一个元素
int firstElement = numbers[0];
// 修改第三个元素
numbers[2] = 50;
// 输出数组长度
System.out.println("数组长度：" + numbers.length);
1
2
3
4
5
6

【 数组操作】
Java提供了Arrays类，该类包含了许多用于操作数组的静态方法，如排序、搜索、填充和复制等。

import java.util.Arrays;
// 对数组进行排序
Arrays.sort(numbers);
// 在数组中搜索元素
int index = Arrays.binarySearch(numbers, 50);
// 填充数组
Arrays.fill(numbers, 10);
1
2
3
4
5
6
7

【注意事项】

• Java数组在创建时必须指定类型，不能像某些动态语言那样存储不同类型的元素。
• 数组是引用类型，当将一个数组赋值给另一个数组时，实际上是将引用赋值，两个数组变量将指向同一块内存空间。
• 数组可以存储基本数据类型值，也可以存储对象引用，但不能直接存储对象本身。
  Java数组是编程中非常基础且重要的数据结构，理解和掌握数组的这些概念和性质对于Java编程至关重要。

2. 数组的内存

在Java中，数组是一种引用数据类型，用于存储多个相同数据类型的元素。
Java中的数组内存分配可以分为两个部分：数组引用的存储和数组元素的存储。

1. 数组引用的存储：数组引用是一个变量，存储在栈内存（Stack）中。当声明一个数组时，比如 int[] arr;，这时只是在栈上分配了一个引用变量 arr，这个变量此时并没有指向任何实际的数组对象。
2. 数组元素的存储：实际的数组元素存储在堆内存（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中添加新元素
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在这个例子中，我们首先创建了一个长度为5的数组 originalArray。然后，我们创建了一个新数组 newArray，其长度是原数组长度的两倍。接着，我们使用一个for循环将 originalArray 中的所有元素复制到 newArray 中。现在，newArray 就是一个长度为10的数组，前5个元素与 originalArray 相同，后5个元素为默认值（对于整型数组，默认值为0）。
这种方法虽然可以实现数组扩容，但效率并不高，因为涉及到数组的复制。在实际应用中，如果需要频繁地对数组进行扩容，通常会使用一些动态数据结构，如 ArrayList，它内部会自动处理数组的扩容问题，并提供更高效的添加和删除元素的操作。

4. 二维数组

在Java中，二维数组是数组的数组，即一个一维数组的每个元素都是一个一维数组。二维数组可以看作是一个表格，有行和列。在内存中，二维数组可以看作是数组的数组，或者是一维数组的嵌套。

二维数组的声明和初始化：

1. 静态初始化：

   int[][] myArray = {
       {1, 2, 3},    // 第一行
       {4, 5, 6},    // 第二行
       {7, 8, 9}     // 第三行
   };
   1
   2
   3
   4
   5

2. 动态初始化：

   int rows = 3;
   int cols = 4;
   int[][] myArray = new int[rows][cols]; // 创建一个3行4列的二维数组
   1
   2
   3

   在动态初始化的情况下，每个一维数组默认初始化为其元素类型的默认值（例如，整型为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(); // 换行
}
1
2
3
4
5
6

注意事项：

• Java中的二维数组不必是规则的，即每一行的列数可以不同。
• 二维数组的每一行实际上是一个一维数组，因此每一行的大小可以单独分配。
• 二维数组的内存分配是在堆上进行的，而数组的引用存储在栈上。
• 二维数组的创建和初始化也可以分开进行，先创建数组的引用，然后再为每一行分配空间。

5. 数组的排序

在Java中，数组排序是一个常见的操作，可以通过多种方式实现。以下是一些常用的数组排序方法：

1. 使用Java标准库的排序方法：
   Java的Arrays类提供了一个sort方法，可以用来对数组进行排序。这是最简单和最直接的方法。

   int[] numbers = {3, 1, 4, 1, 5, 9};
   Arrays.sort(numbers);
   1
   2

   对于对象数组，sort方法会使用元素的compareTo方法（如果对象实现了Comparable接口）来进行排序。
2. 使用冒泡排序算法：
   冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。

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

3. 使用快速排序算法：
   快速排序是一种更高效的排序算法，它使用分治法策略来把一个序列分为较小的序列，在递归中分别对它们进行排序。

   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;
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29

4. 使用归并排序算法：
   归并排序是另一种高效的排序算法，它也是一种分治算法，将数组分成若干个小数组，对每个小数组进行排序，然后将小数组合并成较大的数组。

   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];
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39

结语

至此，Java数组讲解完毕。
感谢您的观看！互三必回！持续更新中~！