Java基础03-方法与数组
方法
方法的定义
在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个整数的数组，每个元素被赋予默认的初始值。
-
先声明，然后再使用指定的值进行初始化：
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循环与可变参数：
- 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 类的常用方法：
转换方法
-
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