方法

方法的定义

在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");}
}

数组

数组的定义

• 数组是一种存储相同类型数据的数据结构。在Java中，数组是对象，可以存储基本数据类型或对象。
• 数组的定义包括声明和实例化两个步骤。

数组是引用类型，存在堆内存。

// 声明数组
数据类型[] 数组名;// 实例化数组
数组名 = 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个整数的数组，每个元素被赋予默认的初始值。

3. 先声明，然后再使用指定的值进行初始化：

   int[] scores = new int[]{56, 78, 98};
   

   在这种方式中，数组的声明和初始化在一行完成，同时指定了每个元素的具体值。

4. 简化的数组常量值赋值方式：

   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循环与可变参数：

• Java 5及以上版本引入了增强for循环，用于简化数组和集合的遍历。
• 可变参数（Varargs）是Java 5中引入的一种简化传递可变数量参数的语法。

// 增强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]; // 获取第一个“块”中的第二行第三列的值

注意事项

• 数组索引从0开始。
• 多维数组的各维度的大小可以不同，但每个维度的大小在声明时必须确定。

算法

当涉及到排序算法和查找算法时，Java 提供了很多灵活的工具，但了解一些基本的排序算法和查找算法仍然是很有用的。以下是冒泡排序、选择排序、插入排序和二分查找的简要介绍：

冒泡排序（Bubble Sort）

冒泡排序是一种基础的排序算法，它重复地遍历数组，每次比较相邻的两个元素，如果它们的顺序错误就交换它们，直到整个数组有序。

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;}}}}
}

选择排序（Selection Sort）

选择排序是一种简单直观的排序算法，每次找到数组中的最小元素并将其放在已排序部分的末尾。

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;}}
}

插入排序（Insertion Sort）

插入排序是一种简单直观的排序算法，通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

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;}}
}

二分查找（Binary Search）

二分查找是一种高效的查找算法，但要求数据是有序的。它通过将待查找区域缩小一半的方式快速定位目标元素。

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() 方法。

Arrays工具类

java.util.Arrays 类是 Java 标准库中提供的一个实用工具类，用于对数组进行各种常见操作，包括排序、搜索、比较等。这个类包含了大量的静态方法，使得数组处理更加方便和高效。以下是一些 Arrays 类的常用方法：

转换方法

1. Arrays.toString() 方法用于返回指定数组的字符串表示形式。该方法将数组元素转换为字符串，并用逗号分隔，同时在数组的开头和结尾添加方括号。

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

   [1, 2, 3, 4, 5]

2. 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()将数组转换为ListList<String> list = Arrays.asList(array);// 输出List的内容System.out.println("List: " + list);// 修改数组，会影响到列表array[0] = "grape";// 输出修改后的ListSystem.out.println("Modified List: " + list);}
   }
   

   List: [apple, banana, orange]
   Modified List: [grape, banana, orange]
   

排序方法

1. sort(T[] array) ： 对数组进行升序排序。可以选择提供一个自定义的比较器。

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

2. parallelSort(T[] array) ： 类似于 sort 方法，但是可以在多线程环境中并行执行排序，提高性能。

   int[] arr = {3, 1, 4, 1, 5, 9, 2, 6};
   Arrays.parallelSort(arr);
   

操作数组元素的方法

1. fill(T[] array, T val)： 将数组的所有元素都设置为指定的值。

   int[] arr = new int[5];
   Arrays.fill(arr, 42);
   

2. 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]
   

搜索方法

1. 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
   

比较方法

1. 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

2. 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