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
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符,请联系我的编程经验分享网邮箱:veading@qq.com进行投诉反馈,一经查实,立即删除!