1. 数组概述
数组是一种用于存储多个相同类型元素的数据结构，它具有连续的内存空间和相同的数据类型。数组可以在内存中保存多个相同类型的值，并通过索引进行访问和操作。
2. 一维数组
一维数组是最简单的数组形式，它只包含一个维度。一维数组可以存储多个相同类型的元素。
2.1 创建一维数组
Java中创建一维数组的语法如下：
dataType[] arrayName = new dataType[arraySize];
其中，dataType指定数组中元素的数据类型，arrayName为数组的名称，arraySize为数组的大小。
例如，创建一个长度为5的整型数组：
int[] numbers = new int[5];
2.2 初始化一维数组
一维数组可以通过直接为数组元素赋值进行初始化。也可以使用for循环或者数组初始化列表来初始化一维数组。
例如，使用数组初始化列表初始化整型数组：
int[] numbers = {1, 2, 3, 4, 5};
2.3 使用一维数组
一维数组可以通过索引访问和操作数组元素。数组索引从0开始，最大索引为数组长度减1。
例如，访问一维数组的第二个元素：
int secondNumber = numbers[1];
代码案例：
public class ArrayExample { public static void main(String[] args) { int[] numbers = {1, 2, 3, 4, 5}; // 访问数组元素 System.out.println("第一个元素：" + numbers[0]); System.out.println("第三个元素：" + numbers[2]); // 修改数组元素 numbers[1] = 10; System.out.println("修改后的第二个元素：" + numbers[1]); } }
代码运行结果：
第一个元素：1 第三个元素：3 修改后的第二个元素：10
代码分析：
上述代码创建了一个长度为5的整型数组，并通过索引访问和修改了数组元素。输出结果验证了数组元素的访问和修改操作的正确性。
这些是一维数组的基本使用方法，较为简单。使用一维数组可以很方便地存储和处理一组相同类型的值。
3 二维数组
二维数组是一种存储多个相同类型元素的数据结构，它具有两个维度。二维数组可以看作是由多个一维数组组成的表格，其中每个一维数组称为数组的行，每个元素称为数组的列。
3.1 创建二维数组
Java中创建二维数组的语法如下：
dataType[][] arrayName = new dataType[rowSize][columnSize];
其中，dataType指定数组中元素的数据类型，arrayName为数组的名称，rowSize为数组的行数，columnSize为数组的列数。
例如，创建一个3行4列的整型二维数组：
int[][] matrix = new int[3][4];
3.2 初始化二维数组
二维数组可以通过直接为元素赋值进行初始化。也可以使用嵌套的数组初始化列表来初始化二维数组。
例如，使用初始化列表初始化整型二维数组：
int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
3.3 使用二维数组
二维数组可以通过索引访问和操作数组元素。数组索引从0开始，最大索引为数组行数减1和数组列数减1。
例如，访问二维数组的元素：
int element = matrix[1][2];
代码案例：
public class TwoDimensionalArrayExample { public static void main(String[] args) { int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; // 访问二维数组元素 System.out.println("第一行第二列的元素：" + matrix[0][1]); System.out.println("第三行第一列的元素：" + matrix[2][0]); System.out.println("最后一行最后一列的元素：" + matrix[matrix.length-1][matrix[matrix.length-1].length-1]); // 修改二维数组元素 matrix[1][2] = 10; System.out.println("修改后的第二行第三列的元素：" + matrix[1][2]); } }
代码运行结果：
第一行第二列的元素：2 第三行第一列的元素：7 最后一行最后一列的元素：9 修改后的第二行第三列的元素：10
代码分析：
上述代码创建了一个3行3列的整型二维数组，并通过索引访问和修改了数组元素。输出结果验证了数组元素的访问和修改操作的正确性。
这些是二维数组的基本使用方法，二维数组可以很方便地存储和处理二维表格数据。通过行和列的索引，可以访问和修改二维数组中的元素。
4.数组的基本操作
4.1 遍历数组
遍历数组是指逐个访问数组中的元素。可以使用for循环或者增强型for循环来遍历数组。
代码案例：
public class ArrayOperations { public static void main(String[] args) { int[] numbers = {1, 2, 3, 4, 5}; // 使用for循环遍历数组 System.out.println("使用for循环遍历数组："); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } // 使用增强型for循环遍历数组 System.out.println("使用增强型for循环遍历数组："); for (int number : numbers) { System.out.println(number); } } }
代码运行结果：
使用for循环遍历数组： 1 2 3 4 5 使用增强型for循环遍历数组： 1 2 3 4 5
代码分析：
上述代码演示了使用for循环和增强型for循环两种方式遍历数组。输出结果验证了数组的所有元素都被成功遍历。
4.2 填充替换数组元素
可以使用Arrays类的fill方法来填充数组元素。该方法允许将指定的值赋给数组的所有元素。也可以使用索引直接替换数组中的元素。
代码案例：
import java.util.Arrays; public class ArrayOperations { public static void main(String[] args) { int[] numbers = {1, 2, 3, 4, 5}; // 使用fill方法填充数组元素 Arrays.fill(numbers, 10); System.out.println("填充后的数组：" + Arrays.toString(numbers)); // 使用索引替换数组元素 numbers[2] = 20; System.out.println("替换后的数组：" + Arrays.toString(numbers)); } }
代码运行结果：
填充后的数组：[10, 10, 10, 10, 10] 替换后的数组：[10, 10, 20, 10, 10]
代码分析：
上述代码演示了使用fill方法填充数组所有元素为指定值，并使用索引替换数组中指定位置的元素。输出结果验证了数组元素的填充和替换操作的正确性。
4.3 对数组进行排序
可以使用Arrays类的sort方法对数组进行排序。该方法将数组按升序进行排序。
代码案例：
import java.util.Arrays; public class ArrayOperations { public static void main(String[] args) { int[] numbers = {5, 3, 1, 4, 2}; // 对数组进行排序 Arrays.sort(numbers); System.out.println("排序后的数组：" + Arrays.toString(numbers)); } }
代码运行结果：
排序后的数组：[1, 2, 3, 4, 5]
代码分析：
上述代码演示了使用sort方法对数组进行排序。输出结果验证了数组元素的排序操作的正确性。
4.4 复制数组
可以使用Arrays类的copyOf方法将一个数组复制到另外一个数组中。该方法允许指定复制的长度。
代码案例：
import java.util.Arrays; public class ArrayOperations { public static void main(String[] args) { int[] numbers = {1, 2, 3, 4, 5}; // 复制数组 int[] copyOfNumbers = Arrays.copyOf(numbers, numbers.length); System.out.println("复制后的数组：" + Arrays.toString(copyOfNumbers)); } }
代码运行结果：
复制后的数组：[1, 2, 3, 4, 5]
代码分析：
上述代码演示了使用copyOf方法将一个数组复制到另外一个数组中。输出结果验证了数组的复制操作的正确性。
4.5 查询数组
可以使用Arrays类的binarySearch方法查询数组中指定元素的索引。该方法要求数组首先是有序的。
代码案例：
import java.util.Arrays; public class ArrayOperations { public static void main(String[] args) { int[] numbers = {1, 2, 3, 4, 5}; // 查询数组 int index = Arrays.binarySearch(numbers, 3); System.out.println("元素3的索引位置：" + index); } }
代码运行结果：
元素3的索引位置：2
代码分析：
上述代码演示了使用binarySearch方法查询数组中指定元素的索引。输出结果验证了对数组的查询操作的正确性。
以上是数组的一些基本操作，包括遍历数组、填充替换数组元素、对数组进行排序、复制数组和查询数组。这些操作可以为数组的处理提供便利和灵活性。
5. 数组排序算法
排序是对数组元素进行按照特定规则重新排列的操作。Java提供了多种排序算法，常用的包括冒泡排序、直接选择排序和反转排序。
5.1 冒泡排序
冒泡排序是一种简单直观的排序算法，通过多次遍历数组，比较相邻元素的大小，并交换位置，将最大（或最小）的元素冒泡至数组的最后（或最前）。
代码案例：
public class BubbleSortExample { public static void bubbleSort(int[] array) { int n = array.length; for (int i = 0; i < n - 1; i++) { for (int j = 0; j < n - i - 1; j++) { if (array[j] > array[j + 1]) { int temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp; } } } } public static void main(String[] args) { int[] numbers = {5, 2, 8, 9, 1}; System.out.println("排序前：" + Arrays.toString(numbers)); bubbleSort(numbers); System.out.println("排序后：" + Arrays.toString(numbers)); } }
代码运行结果：
排序前：[5, 2, 8, 9, 1] 排序后：[1, 2, 5, 8, 9]
代码分析：
上述代码使用冒泡排序算法对整型数组进行排序。通过嵌套的循环遍历，依次比较相邻的元素并交换位置，将最大的元素冒泡到数组的尾部。多次遍历后，数组会按照升序排列。
5.2 直接选择排序
直接选择排序是一种简单直观的排序算法，通过每次从未排序的部分选择最小（或最大）的元素，并与未排序部分的第一个元素交换位置，将最小（或最大）的元素放置到已排序部分的末尾。
代码案例：
public class SelectionSortExample { public static void selectionSort(int[] array) { int n = array.length; for (int i = 0; i < n - 1; i++) { int minIndex = i; for (int j = i + 1; j < n; j++) { if (array[j] < array[minIndex]) { minIndex = j; } } int temp = array[minIndex]; array[minIndex] = array[i]; array[i] = temp; } } public static void main(String[] args) { int[] numbers = {5, 2, 8, 9, 1}; System.out.println("排序前：" + Arrays.toString(numbers)); selectionSort(numbers); System.out.println("排序后：" + Arrays.toString(numbers)); } }
代码运行结果：
排序前：[5, 2, 8, 9, 1] 排序后：[1, 2, 5, 8, 9]
代码分析：
上述代码使用直接选择排序算法对整型数组进行排序。通过嵌套的循环遍历，每次从未排序部分选择最小的元素，并与未排序部分的第一个元素交换位置。多次遍历后，数组会按照升序排列。
5.3 反转排序
反转排序，即将数组元素的顺序完全颠倒。
代码案例：
public class ReverseSortExample { public static void reverseSort(int[] array) { int start = 0; int end = array.length - 1; while (start < end) { int temp = array[start]; array[start] = array[end]; array[end] = temp; start++; end--; } } public static void main(String[] args) { int[] numbers = {5, 2, 8, 9, 1}; System.out.println("排序前：" + Arrays.toString(numbers)); reverseSort(numbers); System.out.println("排序后：" + Arrays.toString(numbers)); } }
代码运行结果：
排序前：[5, 2, 8, 9, 1] 排序后：[1, 9, 8, 2, 5]
代码分析：
上述代码通过交换数组元素的位置，将数组的顺序完全颠倒。通过使用两个指针，一个从数组头部开始，一个从数组尾部开始，逐步向中间移动并交换对应位置的元素。最终实现了数组的反转排序。
这些是常用的数组排序算法，包括冒泡排序、直接选择排序和反转排序。通过应用这些算法，可以按照不同的需求对数组进行排序操作。
