搭建公司网站的作用河北搜索引擎优化
第 4 章：IDEA的使用
第 5 章：数组
5.1 数组的概述
数组(Array)：就可以理解为多个数据的组合。
程序中的容器：数组、集合框架（List、Set、Map）。
数组中的概念：
-
数组名
-
下标（或索引）
-
元素
-
数组的长度
数组存储的数据的特点：
-
依次紧密排列的、有序的、可以重复的。
-
数组的其它特点：
-
一旦初始化，其长度就是确定的、不可更改的。
-
数组的下标是从0开始的
-
5.2 一维数组
5.2.1 数组的声明和初始化
代码示例：
int[] arr1 = new int[10];String[] arr2 = new String[]{"Tom","Jerry"};
5.2.2 数组的使用
-
调用数组的指定元素：使用角标、索引、index。
-
index 从 0 开始。
-
数组的属性：length，表示数组的长度。
-
数组的遍历。
-
数组元素的默认初始化值。
5.2.3 一维数组内存分析
-
虚拟机栈：main() 作为一个栈帧，压入栈空间中。在 main() 栈帧中，存储着 arr 变量。arr 记录着数组实体的首地址值。
-
堆：数组实体存储在堆空间中。
-
Java 虚拟机的内存划分：
5.3 二维数组
二维数组本质上是元素类型是一维数组的一维数组。
5.4 数组的常用算法
-
数值型数组的特征值的计算：最大值、最小值、总和、平均值等。
-
数组元素的赋值。
-
数组的复制、赋值。
-
数组的反转。
-
数组的扩容、缩容。
-
数组的查找：
-
线性查找。
-
二分法查找（前提：数组有序）。
-
-
数组的排序：
-
冒泡排序（最简单）。
-
快速排序（最常用）。
-
5.5 Arrays 工具类的使用
-
java.util.Arrays 类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法。
-
toString() 、 sort()、 binarySearch()。
5.6 数组中的常见异常
-
下标越界异常：ArrayIndexOutOfBoundsException
-
空指针异常：NullPointerException
5.7、企业真题
-
数组有没有 length()这个方法? String 有没有 length()这个方法？ 答： 数组没有 length()，有 length 属性。 String 有 length()。
-
有数组 int[] arr，用 Java 代码将数组元素顺序颠倒？ 答： 可以使用两个指针，一个指向数组的第一个元素，另一个指向数组的最后一个元素，交换它们的值，然后继续向中间靠拢，直到两个指针相遇。
public static void reverseArray(int[] arr){int left = 0;int right = arr.length - 1;while (left < right){int temp = arr[left];arr[left] = arr[right];arr[right] = temp;left++;right--;}}public static void main(String[] args){int[] arr = {1, 2, 3, 4, 5}; // 定义一个数组System.out.println("原数组：" + Arrays.toString(arr)); // 输出原数组reverseArray(arr); // 调用方法将数组元素顺序颠倒System.out.println("颠倒后的数组：" + Arrays.toString(arr)); // 输出颠倒后的数组}运行该主函数，输出结果如下：
原数组：[1, 2, 3, 4, 5]颠倒后的数组：[5, 4, 3, 2, 1]
-
为什么数组要从 0 开始编号，而不是 1？ 答： 数组的索引，表示了数组元素距离首地址的偏离量。因为第 1 个元素的地址与首地址相同，所以偏移量就是 0，所以数组要从 0 开始。
-
数组有什么排序的方式，手写一下？ 答： 常见的数组排序方式有冒泡排序、选择排序、插入排序、快速排序、归并排序等。
冒泡排序： 冒泡排序的思路是从第一个元素开始，依次比较相邻的两个元素，如果前一个元素比后一个元素大，则交换它们的位置。这样一轮下来，最大的元素就会被移动到最后一个位置。然后再从第一个元素开始，继续进行比较和交换，直到所有元素都被排序。
public class BubbleSort{public static void main(String[] args){int[] arr = {3, 9, 1, 8, 2, 5, 7};bubbleSort(arr);for(int i = 0; i < arr.length; i++){System.out.print(arr[i] + " ");}}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]){int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}}冒泡排序的时间复杂度为 O(n^2)，空间复杂度为 O(1)。
快速排序： 快速排序的思路是选取一个基准元素，将数组分为左右两部分，左半部分的元素均小于等于基准元素，右半部分的元素均大于等于基准元素。然后对左右两部分分别进行快速排序，直到整个数组有序。在上面的代码中，partition 方法用于实现分区，将数组分为左右两部分。quickSort 方法用于实现快速排序，递归调用自身对左右两部分进行排序。
public class QuickSort{public static void main(String[] args){int[] arr = {5, 2, 9, 3, 7, 6, 1, 8, 4};quickSort(arr, 0, arr.length - 1);for (int i : arr){System.out.print(i + " ");}}public static void quickSort(int[] arr, int left, int right){if (left < right){int pivot = partition(arr, left, right);quickSort(arr, left, pivot - 1);quickSort(arr, pivot + 1, right);}}public static int partition(int[] arr, int left, int right){int pivot = arr[left];while (left < right){while (left < right && arr[right] >= pivot){right--;}arr[left] = arr[right];while (left < right && arr[left] <= pivot){left++;}arr[right] = arr[left];}arr[left] = pivot;return left;}}快速排序的时间复杂度为 O(nlogn)，空间复杂度为 O(logn)。
-
二分算法实现数组的查找？ 答： 二分查找思路： ① 首先确定要查找的数组的范围，即左右边界； ② 计算中间位置，即中间索引值； ③ 判断中间值是否等于要查找的值，如果是，则返回中间索引值； ④ 如果中间值大于要查找的值，则在左半部分继续查找，即将右边界设为中间索引值减一； ⑤ 如果中间值小于要查找的值，则在右半部分继续查找，即将左边界设为中间索引值加一； ⑥ 重复 ②-⑤ 步骤，直到找到要查找的值或左右边界重合，此时返回-1 表示未找到。
public class BinarySearch{public static int binarySearch(int[] arr, int key){int low = 0;int high = arr.length - 1;while (low <= high){int mid = (low + high) / 2;if (key < arr[mid]){high = mid - 1;}else if (key > arr[mid]){low = mid + 1;}else{return mid;}}return -1;}public static void main(String[] args){int[] arr = {1, 3, 5, 7, 9};int key = 3;int index = binarySearch(arr, key);if (index == -1){System.out.println("找不到指定的元素");}else{System.out.println("指定元素的索引为：" + index);}}}复杂度分析： 时间复杂度为 O(log n)，因为每次查找都将查找范围缩小一半，最坏情况下需要查找 log n 次，其中 n 为数组长度。 空间复杂度为 O(1)，因为只需要常数个额外变量存储查找范围的左右边界和中间索引值。
-
怎么求数组的最大子序列和? 答： 以下是一个使用 Java 实现的求解最大子序列和的示例代码：
这个算法的思路是使用动态规划的思想。
我们从左到右遍历整个数组，使用两个变量 maxSum 和 currentSum 来记录最大子序列和和当前子序列和。
对于当前遍历到的元素 nums[i]，我们可以有两种选择： 将 nums[i] 加入当前子序列中，即 currentSum = currentSum + nums[i]； 以 nums[i] 作为新的起点开始一个新的子序列，即 currentSum = nums[i]。
我们需要比较这两种选择哪个更优，即选择 currentSum + nums[i] 或选择 nums[i] 中的较大值作为当前子序列的和 currentSum。同时，我们需要比较当前子序列的和 currentSum 和最大子序列和 maxSum 哪个更大，即选择 Math.max(maxSum, currentSum)作为新的最大子序列和 maxSum。
最后，遍历完成后 maxSum 就是最大子序列和。
public class MaxSubArraySum{public static int maxSubArraySum(int[] nums){int maxSum = nums[0];int currentSum = nums[0];for (int i = 1; i < nums.length; i++){currentSum = Math.max(currentSum + nums[i], nums[i]);maxSum = Math.max(maxSum, currentSum);}return maxSum;}public static void main(String[] args){int[] nums = {-2, 1, -3, 4, -1, 2, 1, -5, 4};int maxSum = maxSubArraySum(nums);System.out.println("最大子序列和为：" + maxSum);}}输出：
最大子序列和为：6
解释：最大子序列为[4, -1, 2, 1]，和为 6。
-
Arrays 类的排序方法是什么？如何实现排序的？ 答： Arrays 类提供了多种排序方法，包括： ① sort(Object[] a)：对数组 a 进行升序排序，元素类型必须实现 Comparable 接口。 ② sort(Object[] a, Comparator c)：对数组 a 进行排序，使用自定义的 Comparator 比较器进行比较。 ③ parallelSort(Object[] a)：对数组 a 进行并行排序，效率更高。
排序的实现原理主要是基于快速排序和归并排序，具体实现方式根据元素类型和排序方法不同而不同。
在 sort(Object[] a) 方法中，对于实现了 Comparable 接口的元素类型，通过 compareTo() 方法进行比较，并且使用快速排序实现；对于未实现 Comparable 接口的元素类型，则会抛出 ClassCastException 异常。
在 sort(Object[] a, Comparator c) 方法中，通过传入自定义的 Comparator 比较器进行比较，也使用快速排序实现。 在 parallelSort(Object[] a) 方法中，使用 Fork/Join 框架实现并行排序，将数组拆分成多个小数组进行排序，最后再合并起来。