零基础学Java（4）
碎碎念：我勒个豆！写了这么多天才发现还有好多基础的知识居然没写！！！算了算了，以后如何需要的话再系统地写一遍吧，现在就想到哪写到哪......
关于print和printf
可变参数
参考文献可以放 3 篇、5 篇甚至 10 篇，格式统一只需要按顺序罗列；Java 的可变参数也一样，允许方法接收 “任意个数” 的同类型参数，不用提前定义参数个数，代码更灵活简洁。
语法格式
修饰符 返回值类型 方法名(参数类型... 参数名) { // 方法体 }- 关键符号：
...（三个点，放在参数类型后、参数名前）； - 注意事项：一个方法只能有一个可变参数，且必须放在参数列表的最后一位。
实操案例
public class VarargsDemo { // 可变参数方法：接收任意个数的int类型参数（0个、1个、多个都可以） public static int sum(int... nums) { int total = 0; // 可变参数本质是数组，用普通for循环遍历即可 for (int num : nums) { // 增强for循环遍历（更简洁） total += num; } return total; } public static void main(String[] args) { // 调用可变参数方法：传入任意个数的参数 System.out.println(sum()); // 传入0个参数，输出0 System.out.println(sum(1)); // 传入1个参数，输出1 System.out.println(sum(1, 2)); // 传入2个参数，输出3 System.out.println(sum(1, 2, 3, 4, 5)); // 传入5个参数，输出15 } }核心特性
1、本质是数组：编译器会自动把int... nums转为int[] nums，你可以像操作普通数组一样操作可变参数（比如通过nums.length获取参数个数）：
public static int sum(int... nums) { System.out.println("传入的参数个数：" + nums.length); int total = 0; for (int i = 0; i < nums.length; i++) { // 普通for循环遍历 total += nums[i]; } return total; } 2、参数灵活性：
- 可传入 0 个参数（此时
nums是长度为 0 的空数组，不会报错）；
可直接传入数组：和可变参数兼容，无需额外处理：
int[] arr = {1,2,3}; System.out.println(sum(arr)); // 直接传入数组，输出6 3、优先级规则：当方法重载和可变参数方法同时存在时，编译器会优先调用 “精确匹配” 的普通方法，再调用可变参数方法：
// 普通方法（精确匹配2个int参数） public static int sum(int a, int b) { return a + b + 10; // 额外加10，便于区分 } // 可变参数方法 public static int sum(int... nums) { int total = 0; for (int num : nums) { total += num; } return total; } public static void main(String[] args) { System.out.println(sum(1, 2)); // 优先调用普通方法，输出13（不是3） System.out.println(sum(1, 2, 3)); // 无普通方法匹配，调用可变参数方法，输出6 }递归
递归（Recursion）是 Java 中核心的编程思想之一，核心就是一个方法在其方法体内直接或间接调用自身，就像 “套娃” 一样，通过重复调用自身来拆解复杂问题，最终转化为简单的基础问题求解。
递归组成结构
- 递归出口（终止条件）：什么时候不调用自身方法。如果没有头，将陷入死循环。
- 递归调用：什么时候需要调用自身方法。
实操案例（求 n 的阶乘）
阶乘定义：n! = n * (n-1) * (n-2) * ... * 1，1! = 1，0! = 1
public class RecursionDemo { // 递归方法求n的阶乘 public static int factorial(int n) { // 递归出口：n=0或n=1时，阶乘结果为1，停止递归 if (n == 0 || n == 1) { return 1; } // 递归调用：自身调用，将n!拆解为n * (n-1)! return n * factorial(n - 1); } public static void main(String[] args) { int result = factorial(5); // 计算5的阶乘 System.out.println("5! = " + result); // 输出120 } } 执行流程拆解
factorial(5) → 5 * factorial(4) factorial(4) → 4 * factorial(3) factorial(3) → 3 * factorial(2) factorial(2) → 2 * factorial(1) factorial(1) → 1 （触发递归出口，停止调用，开始回溯） // 回溯计算结果：2*1=2 → 3*2=6 → 4*6=24 → 5*24=120PS：在基数比较小的情况下用递归真的很简洁省事，但面对大基数问题（比如算10000的阶层）就会存在栈溢出等问题，说白了就是便利人类累死计算机......
数组
数组是 Java 中最基础的数据结构之一，核心是一组固定长度、存储相同数据类型的有序容器，一旦创建长度不可改变，就像一排大小一致的储物柜，每个柜子（下标）对应一个数据。
数组的核心特性
- 存储同类型数据：只能存放一种数据类型（如
int[]只能存整数，String[]只能存字符串），不能混合存储； - 固定长度：创建时必须指定长度，后续无法扩容或缩容；
- 有序排列：数据按下标（索引）存放，下标从
0开始，最大下标为长度-1； - 内存连续分配：数组元素在内存中连续存放，访问效率高。
数组的创建与初始化
1. 静态初始化（已知具体元素，自动推导长度）
// 语法：数据类型[] 数组名 = {元素1, 元素2, ..., 元素n}; int[] numArr = {1, 2, 3, 4, 5}; // 整数数组 String[] nameArr = {"张三", "李四", "王五"}; // 字符串数组 数组的申明有两种方式：int[ ] arr; 和 int arr[ ]; 两种方法的效果相同，但前者为首选方法，后者是C和C++语言风格的数组申明方式。
2. 动态初始化（未知具体元素，先指定长度）
// 语法：数据类型[] 数组名 = new 数据类型[长度]; int[] scoreArr = new int[3]; // 创建长度为3的整数数组，默认值为0 String[] addrArr = new String[2]; // 创建长度为2的字符串数组，默认值为null // 动态初始化后，手动赋值（通过下标赋值） scoreArr[0] = 85; scoreArr[1] = 90; scoreArr[2] = 78;数组的访问与遍历
1. 单个元素访问
通过数组名[下标]访问，下标不能超出0 ~长度-1，否则抛出ArrayIndexOutOfBoundsException（数组下标越界异常）。
int[] numArr = {1, 2, 3, 4, 5}; System.out.println(numArr[0]); // 访问第1个元素，输出1 System.out.println(numArr[4]); // 访问最后1个元素，输出5 // System.out.println(numArr[5]); // 报错：下标越界（长度为5，最大下标为4） 2. 数组遍历
int[] numArr = {1, 2, 3, 4, 5}; // 方式1：普通for循环（可操作下标，灵活控制遍历范围） for (int i = 0; i < numArr.length; i++) { // numArr.length 获取数组长度 System.out.print(numArr[i] + " "); // 输出：1 2 3 4 5 } System.out.println(); // 方式2：增强for循环（foreach，无需关注下标，仅遍历所有元素） for (int num : numArr) { System.out.print(num + " "); // 输出：1 2 3 4 5 }对于方式2，我们在学习for循环时有提到过，所以重点可以了解一下方式1的“ .length”。
数组的常见操作
1. 求数组最大值
public static int getMax(int[] arr) { int max = arr[0]; // 假设第一个元素为最大值 for (int num : arr) { if (num > max) { max = num; // 更新最大值 } } return max; } 2. 数组元素反转
public static void reverseArr(int[] arr) { for (int i = 0; i < arr.length / 2; i++) { // 交换 arr[i] 和 arr[arr.length-1-i] int temp = arr[i]; arr[i] = arr[arr.length - 1 - i]; arr[arr.length - 1 - i] = temp; } }拓展
二维数组
在现阶段Java的学习中，多维数组的运用并不频繁，这里只是做个小小的拓展。
二维数组本质是 “数组的数组”，用于存储表格型数据（行 + 列）。
// 静态初始化 int[][] twoDArr = {{1, 2}, {3, 4}, {5, 6}}; // 访问元素：行下标 + 列下标 System.out.println(twoDArr[0][1]); // 输出2（第1行第2列） // 遍历二维数组 for (int i = 0; i < twoDArr.length; i++) { // 遍历行 for (int j = 0; j < twoDArr[i].length; j++) { // 遍历每行的列 System.out.print(twoDArr[i][j] + " "); } System.out.println(); }Arrays 类
Java 中的 Arrays 类（位于 java.util 包下）是专门为数组提供便捷操作方法的工具类，它封装了大量数组相关的静态方法，能帮我们快速实现数组排序、查找、填充、比较、转换等功能。
以下以 int[] 数组为例，演示 Arrays 类的高频使用方法：
public class ArraysDemo { public static void main(String[] args) { int[] arr = {3, 1, 4, 1, 5, 9, 2, 6}; int[] arr2 = {3, 1, 4, 1, 5, 9, 2, 6}; int[] arr3 = new int[5]; // 1. 数组转字符串：直观打印数组内容（无需手动遍历） String arrStr = Arrays.toString(arr); System.out.println("数组原始内容：" + arrStr); // 输出：[3, 1, 4, 1, 5, 9, 2, 6] // 2. 数组排序：默认升序排序（快速排序算法） Arrays.sort(arr); System.out.println("排序后数组：" + Arrays.toString(arr)); // 输出：[1, 1, 2, 3, 4, 5, 6, 9] // 3. 二分查找：在**已排序**的数组中查找指定元素，返回下标；未找到返回负数 // 注意：必须先排序，否则查找结果无效 int index = Arrays.binarySearch(arr, 5); System.out.println("元素5在排序后数组中的下标：" + index); // 输出：5 // 4. 数组填充：将指定值填充到数组的所有位置 Arrays.fill(arr3, 10); System.out.println("填充后数组arr3：" + Arrays.toString(arr3)); // 输出：[10, 10, 10, 10, 10] // 5. 数组比较：判断两个数组的长度和对应位置元素是否完全一致 boolean isEqual = Arrays.equals(arr, arr2); System.out.println("arr和arr2是否相等：" + isEqual); // 输出：false（arr已排序，arr2未排序） // 6. 数组复制：复制指定长度的数组，比手动遍历复制更高效 // copyOf(原数组, 新数组长度)：长度不足补默认值，超出截断 int[] arrCopy = Arrays.copyOf(arr, 6); System.out.println("复制后数组（长度6）：" + Arrays.toString(arrCopy)); // 输出：[1, 1, 2, 3, 4, 5] } }
