在Java中，方法是一组执行特定任务的代码块。方法定义由以下几个部分组成：
修饰符 返回类型 方法名(参数列表) {
// 方法体
}
public、private等）。void。一个简单的例子：
public int add(int a, int b) {
return a + b;
}
例如，在上述add方法中，a和b就是形参，而在调用方法时传递给它的具体数字就是实参：
int result = add(3, 5); // 这里的3和5就是实参
void，表示不返回任何值。return 语句将值返回给调用方。例如，在前面的add方法中，返回类型是int，并使用 return a + b; 返回计算结果。
例如：
public int add(int a, int b) {
return a + b;
}
public double add(double a, double b) {
return a + b;
}
这两个add方法是重载关系，一个接收整数，另一个接收双精度浮点数。
重载示例
public class BookManager {
// 添加图书，接收图书名和作者
public void addBook(String title, String author) {
System.out.println("Added book: " + title + " by " + author);
// 其他逻辑...
}
// 添加图书，接收图书名、作者和出版年份
public void addBook(String title, String author, int year) {
System.out.println("Added book: " + title + " by " + author + ", published in " + year);
// 其他逻辑...
}
// 添加图书，接收图书名、作者、出版年份和ISBN号
public void addBook(String title, String author, int year, String isbn) {
System.out.println("Added book: " + title + " by " + author + ", published in " + year + ", ISBN: " + isbn);
// 其他逻辑...
}
public static void main(String[] args) {
BookManager bookManager = new BookManager();
// 不同的方法版本，根据需要选择
bookManager.addBook("The Catcher in the Rye", "J.D. Salinger");
bookManager.addBook("To Kill a Mockingbird", "Harper Lee", 1960);
bookManager.addBook("1984", "George Orwell", 1949, "978-0451524935");
}
}
数组是引用类型，存在堆内存。
// 声明数组
数据类型[] 数组名;
// 实例化数组
数组名 = new 数据类型[数组长度];
例如，声明并实例化一个整数数组：
int[] numbers;
numbers = new int[5]; // 创建一个包含5个整数的数组
数组元素可以通过索引进行赋值。数组的索引从0开始，最大索引是数组长度减1。
使用默认的初始值来初始化数组中的每一个元素：
int[] scores = new int[3];
在这种方式中，scores 数组被初始化为包含3个整数的数组，每个元素都会被赋予默认的初始值，对于整数数组来说，默认初始值是0。
先声明，然后再赋予默认的初始值：
int[] scores;
scores = new int[3];
这种方式将数组的声明和实例化分成两个步骤，同样，scores 数组被初始化为包含3个整数的数组，每个元素被赋予默认的初始值。
先声明，然后再使用指定的值进行初始化：
int[] scores = new int[]{56, 78, 98};
在这种方式中，数组的声明和初始化在一行完成，同时指定了每个元素的具体值。
简化的数组常量值赋值方式：
int[] scores = {56, 78, 98};
这种方式是对第三种方式的简化，Java 编译器会根据提供的常量值自动确定数组的长度。
求数组的长度 arr.length
for循环或while循环）可以遍历数组中的所有元素。int[] numbers = {10, 20, 30, 40, 50};
// 使用for循环遍历数组
for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}
// 使用增强for循环遍历数组（下面会详细介绍）
for (int num : numbers) {
System.out.println(num);
}
增强for循环与可变参数：
// 增强for循环遍历数组
int[] numbers = {10, 20, 30};
for (int num : numbers) {
System.out.println(num);
}
// 可变参数的方法
public static void printNumbers(int... nums) {
for (int num : nums) {
System.out.println(num);
}
}
// 调用可变参数的方法
printNumbers(10, 20, 30, 40);
在增强for循环中，不需要使用索引，直接遍历数组中的每个元素。可变参数允许方法接受可变数量的参数，使得调用者在传递参数时更加灵活。在上面的例子中，printNumbers 方法可以接受任意数量的整数参数。
二维数组是数组的数组，每个元素都是一个一维数组。在 Java 中，你可以这样声明和初始化一个二维数组：
// 声明和初始化一个二维数组
int[][] twoDArray = new int[3][4];
// 或者
int[][] anotherTwoDArray = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
上面的例子中，twoDArray 是一个 3x4 的二维数组，而 anotherTwoDArray 则是一个初始化后的 3x3 二维数组。
同样，你可以创建三维数组：
// 声明和初始化一个三维数组
int[][][] threeDArray = new int[2][3][4];
// 或者
int[][][] anotherThreeDArray = { { {1, 2}, {3, 4}, {5, 6} }, { {7, 8}, {9, 10}, {11, 12} } };
上述代码中，threeDArray 是一个 2x3x4 的三维数组，anotherThreeDArray 是一个初始化后的 2x3x2 三维数组。
访问多维数组的元素需要使用相应的索引。例如，访问二维数组的元素：
int value = twoDArray[1][2]; // 获取第二行第三列的值
同样，对于三维数组：
int value = threeDArray[0][1][2]; // 获取第一个“块”中的第二行第三列的值
当涉及到排序算法和查找算法时，Java 提供了很多灵活的工具，但了解一些基本的排序算法和查找算法仍然是很有用的。以下是冒泡排序、选择排序、插入排序和二分查找的简要介绍：
冒泡排序是一种基础的排序算法，它重复地遍历数组，每次比较相邻的两个元素，如果它们的顺序错误就交换它们，直到整个数组有序。
public class BubbleSort {
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]) {
// 交换array[j]和array[j+1]
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
}
}
选择排序是一种简单直观的排序算法，每次找到数组中的最小元素并将其放在已排序部分的末尾。
public class SelectionSort {
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;
}
}
// 交换array[i]和array[minIndex]
int temp = array[i];
array[i] = array[minIndex];
array[minIndex] = temp;
}
}
}
插入排序是一种简单直观的排序算法，通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
public class InsertionSort {
public static void insertionSort(int[] array) {
int n = array.length;
for (int i = 1; i < n; i++) {
int key = array[i];
int j = i - 1;
while (j >= 0 && array[j] > key) {
array[j + 1] = array[j];
j--;
}
array[j + 1] = key;
}
}
}
二分查找是一种高效的查找算法，但要求数据是有序的。它通过将待查找区域缩小一半的方式快速定位目标元素。
public class BinarySearch {
public static int binarySearch(int[] array, int target) {
int low = 0;
int high = array.length - 1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (array[mid] == target) {
return mid; // 找到目标元素
} else if (array[mid] < target) {
low = mid + 1; // 在右半边继续搜索
} else {
high = mid - 1; // 在左半边继续搜索
}
}
return -1; // 目标元素不在数组中
}
}
这些算法是基础的排序和查找算法，理解它们有助于建立对算法的基本认识。在实际应用中，Java 的 Arrays 类提供了一些现成的排序算法，而查找算法可以使用 Arrays.binarySearch() 方法。
java.util.Arrays 类是 Java 标准库中提供的一个实用工具类，用于对数组进行各种常见操作，包括排序、搜索、比较等。这个类包含了大量的静态方法，使得数组处理更加方便和高效。以下是一些 Arrays 类的常用方法：
Arrays.toString() 方法用于返回指定数组的字符串表示形式。该方法将数组元素转换为字符串，并用逗号分隔，同时在数组的开头和结尾添加方括号。
int[] arr = {1, 2, 3, 4, 5};
String arrayString = Arrays.toString(arr);
System.out.println(arrayString);
[1, 2, 3, 4, 5]
Arrays.asList() 方法用于将指定数组转换为一个固定大小的列表。
import java.util.Arrays;
import java.util.List;
public class ArraysAsListExample {
public static void main(String[] args) {
// 创建一个数组
String[] array = {"apple", "banana", "orange"};
// 使用Arrays.asList()将数组转换为List
List<String> list = Arrays.asList(array);
// 输出List的内容
System.out.println("List: " + list);
// 修改数组，会影响到列表
array[0] = "grape";
// 输出修改后的List
System.out.println("Modified List: " + list);
}
}
List: [apple, banana, orange]
Modified List: [grape, banana, orange]
sort(T[] array) ： 对数组进行升序排序。可以选择提供一个自定义的比较器。
int[] arr = {3, 1, 4, 1, 5, 9, 2, 6};
Arrays.sort(arr);
parallelSort(T[] array) ： 类似于 sort 方法，但是可以在多线程环境中并行执行排序，提高性能。
int[] arr = {3, 1, 4, 1, 5, 9, 2, 6};
Arrays.parallelSort(arr);
fill(T[] array, T val)： 将数组的所有元素都设置为指定的值。
int[] arr = new int[5];
Arrays.fill(arr, 42);
copyOf(T[] original, int newLength)
copyOfRange(T[] original, int from, int to)： 用于复制数组的一部分或整个数组。
int[] arr = {1, 2, 3, 4, 5};
int[] copy = Arrays.copyOf(arr, arr.length);
System.out.println("copy = " + Arrays.toString(copy));
int[] copy1 = Arrays.copyOfRange(arr, 1, 3);
System.out.println("copy1 = " + Arrays.toString(copy1));
int[] destinationArray = new int[arr.length];
System.arraycopy(arr, 0, destinationArray, 0, arr.length);
System.out.println("destinationArray = " + Arrays.toString(destinationArray));
copy = [1, 2, 3, 4, 5]
copy1 = [2, 3]
destinationArray = [1, 2, 3, 4, 5]
binarySearch(T[] a, T key) 和 binarySearch(T[] a, int fromIndex, int toIndex, T key)： 使用二分查找算法在有序数组中搜索指定元素。
int[] arr = {1, 2, 3, 4, 5};
int index = Arrays.binarySearch(arr, 3);
System.out.println("index = " + index);
index = 2
equals(T[] a, T[] a2)： 比较两个数组是否相等。
int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
boolean isEqual = Arrays.equals(arr1, arr2);
System.out.println("isEqual = " + isEqual);
isEqual = true
deepEquals(Object[] a1, Object[] a2)： 深度比较两个对象数组是否相等（适用于多维数组）。
int[][] arr1 = {{1, 2}, {3, 4}};
int[][] arr2 = {{1, 2}, {3, 4}};
boolean isEqual = Arrays.deepEquals(arr1, arr2);
System.out.println("isEqual = " + isEqual);
isEqual = true