1、Java数组（Arrays）语法知识点及案例

一、数组的基本概念

数组是多个相同类型的数据按照一定的顺序排列的集合，使用一个名字命名，通过编号（索引）的方式对这些数据进行统一管理。数组是引用数据类型，数组的元素可以是任意类型。数组一旦初始化，长度则不能更改。

二、数组的分类

• 维度分：一维数组、二维数组、多维数组
• 元素分：基本数据类型元素数组、引用数据类型元素数组

三、一维数组

1. 数组的声明和初始化
   • 静态初始化：数组的初始化和数组元素的赋值操作同时进行。
   • 动态初始化：数组的初始化和数组元素的赋值操作分开进行。

// 静态初始化
int[] id = {1001, 1002, 1003, 1004};// 动态初始化
String[] name = new String[5];

2. 调用数组指定位置的元素
   通过索引方式调用，数组的索引从0开始，到（长度-1）结束。

// 调用数组name的第1个元素（索引为0）
name[0] = "Alice";

3. 获取数组的长度

// 获取数组name的长度
int length = name.length; // 5

4. 遍历数组

// 使用for循环遍历数组name
for (int i = 0; i < name.length; i++) {System.out.println(name[i]);
}

5. 数组元素默认初始化值
   • 基本数据类型数组：默认初始化值为0（整数类型）、0.0（浮点类型）、false（布尔类型）、‘\u0000’（字符类型）。
   • 引用数据类型数组：默认初始化值为null。

四、多维数组

1. 二维数组的初始化
   • 静态初始化

int[][] arr1 = {{1, 2, 3},{4, 5},{6, 7, 8}
};

• 动态初始化

String[][] arr2 = new String[3][2];

2. 调用二维数组指定位置的元素

// 调用二维数组arr1的第1行第2列的元素（索引为[0][1]）
int value = arr1[0][1]; // 2

3. 获取二维数组的长度

// 获取二维数组arr1的外层长度（行数）
int outerLength = arr1.length; // 3// 获取二维数组arr1的第1行的内层长度（列数）
int innerLength = arr1[0].length; // 3

4. 遍历二维数组

// 使用嵌套for循环遍历二维数组arr1
for (int i = 0; i < arr1.length; i++) {for (int j = 0; j < arr1[i].length; j++) {System.out.print(arr1[i][j] + " ");}System.out.println();
}

五、Arrays类中的常用方法

1. copyOf
   • 用于复制数组，返回一个新数组，其长度为指定长度，元素为原数组的值。

int[] arr5 = {7, 8, 9};
int[] arr6 = Arrays.copyOf(arr5, 5);
System.out.println(Arrays.toString(arr6)); // [7, 8, 9, 0, 0]

2. sort
   • 对数组进行排序。

int[] arr3 = {5, 4, 6};
Arrays.sort(arr3);
System.out.println(Arrays.toString(arr3)); // [4, 5, 6]

3. binarySearch
   • 使用二分查找算法查找元素的下标，要求数组已经按升序排列。

int[] arr7 = {1, 2, 3, 4, 5};
Arrays.sort(arr7);
int index = Arrays.binarySearch(arr7, 3);
System.out.println(index); // 2

4. fill
   • 将数组的所有元素设置为指定值。

String[] arr4 = {"你", "好"};
Arrays.fill(arr4, "小维");
System.out.println(Arrays.toString(arr4)); // [小维, 小维]

5. equals
   • 比较两个数组是否相等。

int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
boolean isEqual = Arrays.equals(arr1, arr2);
System.out.println(isEqual); // true

6. toString
   • 将数组转换为字符串。

int[] arr = {1, 2, 3};
String str = Arrays.toString(arr);
System.out.println(str); // [1, 2, 3]

六、综合案例

public class ArrayDemo {public static void main(String[] args) {// 一维数组int[] numbers = {1, 2, 3, 4, 5};System.out.println("一维数组：");for (int number : numbers) {System.out.print(number + " ");}System.out.println();// 二维数组int[][] matrix = {{1, 2, 3},{4, 5, 6},{7, 8, 9}};System.out.println("二维数组：");for (int[] row : matrix) {for (int element : row) {System.out.print(element + " ");}System.out.println();}// Arrays类的使用int[] arr1 = {7, 8, 9};int[] arr2 = Arrays.copyOf(arr1, 5);System.out.println("复制后的数组：" + Arrays.toString(arr2));int[] arr3 = {5, 3, 8, 6, 2};Arrays.sort(arr3);System.out.println("排序后的数组：" + Arrays.toString(arr3));int index = Arrays.binarySearch(arr3, 6);System.out.println("元素6的下标：" + index);String[] arr4 = {"a", "b", "c"};Arrays.fill(arr4, "x");System.out.println("填充后的数组：" + Arrays.toString(arr4));int[] arr5 = {1, 2, 3};int[] arr6 = {1, 2, 3};boolean isEqual = Arrays.equals(arr5, arr6);System.out.println("数组是否相等：" + isEqual);}
}

以上内容涵盖了Java数组的基本语法知识点，并通过具体案例和详细注释展示了如何使用这些知识点。

在Java中，数组是一种重要的数据结构，用于存储固定大小的同类型元素集合。Java标准库提供了Arrays类，其中包含了一系列用于操作数组的静态方法。以下是Java数组中常用的操作函数及其功能介绍：

1. 排序（Sort）

   • Arrays.sort(T[] a)：对指定数组按其元素的自然顺序进行升序排序。此方法适用于所有实现了Comparable接口的元素类型。
   • Arrays.sort(T[] a, int fromIndex, int toIndex)：对指定数组的指定范围进行排序。
   • Arrays.sort(T[] a, Comparator<? super T> c)：根据指定比较器产生的顺序对数组进行排序。

2. 搜索（Search）

   • Arrays.binarySearch(T[] a, T key)：使用二分查找算法在已排序数组中查找指定元素的下标。如果找到，则返回其索引；如果未找到，则返回负值，其绝对值是第一个大于关键字的元素索引减一（如果关键字小于所有元素，则返回-length-1）。
   • Arrays.binarySearch(T[] a, int fromIndex, int toIndex, T key)：在指定范围内进行二分查找。

3. 复制（Copy）

   • Arrays.copyOf(T[] original, int newLength)：复制指定数组，并调整新数组的长度。如果新长度大于原数组长度，则新数组中的新元素将被设置为null（对于对象数组）或0（对于基本类型数组）。
   • Arrays.copyOfRange(T[] original, int from, int to)：复制指定数组范围的元素到新数组。from是起始索引（包含），to是结束索引（不包含）。

4. 填充（Fill）

   • Arrays.fill(T[] a, T val)：将指定值分配给指定数组的每个元素。
   • Arrays.fill(T[] a, int fromIndex, int toIndex, T val)：将指定值分配给指定数组范围的每个元素。

5. 比较（Equals）

   • Arrays.equals(T[] a, T[] a2)：如果两个数组长度相同且内容相同，则返回true；否则返回false。

6. 转换为字符串（ToString）

   • Arrays.toString(T[] a)：返回指定数组内容的字符串表示形式。
     以下是一些使用上述函数的示例代码：

import java.util.Arrays;public class ArrayOperations {public static void main(String[] args) {// 排序Integer[] numbers = {5, 3, 8, 6, 2};Arrays.sort(numbers);System.out.println("排序后的数组：" + Arrays.toString(numbers));// 搜索int index = Arrays.binarySearch(numbers, 6);System.out.println("元素6的下标：" + index);// 复制Integer[] copy = Arrays.copyOf(numbers, numbers.length + 2);System.out.println("复制后的数组：" + Arrays.toString(copy));// 填充Arrays.fill(copy, copy.length - 2, copy.length, 99);System.out.println("填充后的数组：" + Arrays.toString(copy));// 比较Integer[] arr1 = {1, 2, 3};Integer[] arr2 = {1, 2, 3};boolean isEqual = Arrays.equals(arr1, arr2);System.out.println("数组是否相等：" + isEqual);// 转换为字符串String str = Arrays.toString(arr1);System.out.println("数组转换为字符串：" + str);}
}

以上代码展示了如何使用Java数组中的常用操作函数进行排序、搜索、复制、填充、比较和转换为字符串等操作。这些函数使得数组操作更加简洁和高效。

当然可以，以下是一些具体的Java数组操作案例：

一、数组遍历

public class ArrayTraversal {public static void main(String[] args) {int[] arr = {10, 21, 18, 12, 22};System.out.println("数组中元素个数:" + arr.length);for (int i = 0; i < arr.length; i++) {System.out.println("arr[" + i + "]=" + arr[i]);}}
}

二、数组求和

public class ArraySum {public static void main(String[] args) {int[] arr = {23, 11, 25, 88, 45, 22, 88};int sum = add(arr);System.out.println("sum=" + sum);}public static int add(int[] arr) {int sum = 0;for (int x = 0; x < arr.length; x++) {sum = sum + arr[x];}return sum;}
}

三、数组求最值

public class ArrayMax {public static void main(String[] args) {int[] arr = {23, 55, 55, 45, 90, 11};int max = getMax(arr);System.out.println("max=" + max);}public static int getMax(int[] arr) {int max = arr[0];for (int x = 1; x < arr.length; x++) {if (arr[x] > max) {max = arr[x];}}return max;}
}

四、数组排序

以下是几种常见的数组排序方法：

1. 冒泡排序

public class BubbleSort {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;}}}}
}

2. 选择排序

public class SelectionSort {public static void selectionSort(int[] arr) {int n = arr.length;for (int i = 0; i < n - 1; i++) {int minIndex = i;for (int j = i + 1; j < n; j++) {if (arr[j] < arr[minIndex]) {minIndex = j;}}int temp = arr[minIndex];arr[minIndex] = arr[i];arr[i] = temp;}}
}

五、数组查找

1. 线性查找

public class SequentialSearch {public static void main(String[] args) {int[] arr = {45, 62, 15, 62, 78, 30};int index = sequentialSearch(arr, 62);System.out.println("指定元素首次出现的下标位置:" + index);}public static int sequentialSearch(int[] arr, int value) {for (int i = 0; i < arr.length; i++) {if (arr[i] == value) {return i;}}return -1;}
}

2. 二分查找

public class BinarySearch {public static void main(String[] args) {int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 11, 11, 11, 11, 11};int index = binarySearch(arr, 11);System.out.println("指定元素出现的下标位置:" + index);}public static int binarySearch(int[] arr, int val) {int low = 0;int high = arr.length - 1;while (low <= high) {int mid = (low + high) / 2;if (val > arr[mid]) {low = mid + 1;} else if (val < arr[mid]) {high = mid - 1;} else {return mid;}}return -1;}
}

六、数组复制

import java.util.Arrays;public class ArrayCopy {public static void main(String[] args) {int[] src = {1, 3, 5, 7, 9, 11, 13, 15, 17};int[] dest = new int[src.length];// 使用System.arraycopy复制数组System.arraycopy(src, 0, dest, 0, src.length);System.out.println(Arrays.toString(dest));// 使用Arrays.copyOf复制数组int[] copyOf = Arrays.copyOf(src, src.length);System.out.println(Arrays.toString(copyOf));// 使用Arrays.copyOfRange复制数组的一部分int[] copyOfRange = Arrays.copyOfRange(src, 2, 6);System.out.println(Arrays.toString(copyOfRange));}
}

七、数组转字符串

public class ArrayToString {public static void main(String[] args) {int[] arr = {22, 22, 13, 85, 15};String str = toString(arr);System.out.println(str);}public static String toString(int[] arr) {StringBuilder sb = new StringBuilder();for (int x = 0; x < arr.length; x++) {if (x != arr.length - 1) {sb.append(arr[x]).append(",");} else {sb.append(arr[x]);}}return sb.toString();}
}

八、数组反转

public class ArrayReverse {public static void main(String[] args) {int[] arr = {13, 22, 8, 7, 15};printArray(arr);reverseArray(arr);printArray(arr);}public static void reverseArray(int[] arr) {for (int start = 0, end = arr.length - 1; start < end; start++, end--) {int temp = arr[start];arr[start] = arr[end];arr[end] = temp;}}public static void printArray(int[] arr) {for (int i = 0; i < arr.length; i++) {if (i != arr.length - 1) {System.out.print(arr[i] + ",");} else {System.out.println(arr[i]);}}}
}

九、数组填充

import java.util.Arrays;public class ArrayFill {public static void main(String[] args) {int[] arr = new int[5];Arrays.fill(arr, 10);System.out.println(Arrays.toString(arr));String[] strArr = new String[5];Arrays.fill(strArr, "hello");System.out.println(Arrays.toString(strArr));// 填充指定范围Arrays.fill(arr, 1, 3, 20);System.out.println(Arrays.toString(arr));}
}