JavaSE之可变参数、递归、数组算法与参数传递全解析

最新推荐文章于 2025-08-30 21:44:50 发布
最新推荐文章于 2025-08-30 21:44:50 发布
阅读量1.5k 收藏 17
点赞数 44
CC 4.0 BY-SA版权
文章标签： 算法 java 排序算法 开发语言 intellij idea jvm 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79327445/article/details/151017304

JavaSE之可变参数、递归、数组算法与参数传递全解析

一、可变参数：灵活处理不确定个数的参数

1.1 可变参数概述

在实际开发中，经常会遇到「参数类型确定，但参数个数不确定」的场景（例如：实现多个整数相加、多字符串拼接）。可变参数正是为解决这类问题而生，它允许方法接收任意个数的同类型参数，底层本质是数组，但调用时无需手动创建数组，极大简化了代码。

核心要点：
  • 定义格式：数据类型... 变量名（例如 int... nums、String... strs）
  • 本质：编译后自动转换为数组（String... strs 等价于 String[] strs）
  • 使用限制：
    1. 一个方法中只能定义一个可变参数
    2. 可变参数必须位于参数列表的最后一位（避免参数歧义）

1.2 可变参数实战练习：字符串拼接

需求：定义方法，用指定分隔符拼接多个字符串（如用 - 拼接 ["张无忌","赵敏","小昭","小华"]，结果为 张无忌-赵敏-小昭-小华）。

public class Day08Train {

    public static void main(String[] args) {
        // 调用可变参数方法，直接传递多个字符串，无需手动创建数组
        String str = concat("-", "张无忌", "赵敏", "小昭", "小華");
        System.out.println(str); // 输出结果:张无忌-赵敏-小昭-小華
    }

    /**
     * 字符串拼接方法
     * @param s 分隔符（固定参数，位于可变参数前）
     * @param arr 待拼接的字符串数组（可变参数）
     * @return 拼接后的完整字符串
     */
    public static String concat(String s, String... arr) {
        String str = "";
        for (int i = 0; i < arr.length; i++) {
            // 最后一个元素后不添加分隔符
            if (i == arr.length - 1) {
                str += arr[i];
            } else {
                str += arr[i] + s;
            }
        }
        return str;
    }
}

二、递归算法：自己调用自己的解题思路

2.1 递归概述

递归是一种特殊的编程思想，指方法内部直接或间接调用自身，核心是将复杂问题拆解为「与原问题结构相同但规模更小的子问题」，直到子问题可直接解决（即「递归出口」）。

递归分类：
  • 直接递归：方法自身直接调用自己（如 method() 中调用 method()）
  • 间接递归：多个方法循环调用（如 A() 调用 B()，B() 调用 C()，C() 调用 A()）
关键注意事项：
  1. 必须有明确的递归出口：否则会陷入无限递归，导致「栈内存溢出（StackOverflowError）」
  2. 控制递归调用次数：即使有出口，若调用次数过多（如递归深度超过 1 万次），也会触发栈溢出

2.2 递归经典练习

练习 1：利用递归输出 3 到 1

需求：从指定数字 x 倒序输出到 1，递归出口为 x == 1。

public class RecursionTest1 {
    public static void main(String[] args) {
        method(3); // 输出结果：3 2 1
    }

    public static void method(int x) {
        if (x == 1) {
            System.out.println(x);
            return; // 递归出口：x=1时终止调用
        } else {
            System.out.println(x);
            x--;
            method(x); // 递归调用：方法自身调用，参数规模减小
        }
    }
}
练习 2：求 n 的阶乘

阶乘定义：n! = n × (n-1) × (n-2) × ... × 1（如 5! = 5×4×3×2×1 = 120），递归出口为 n == 1（因 1! = 1）。

public class RecursionTest2 {
    public static void main(String[] args) {
        int result = factorial(5);
        System.out.println(result); // 输出结果：120
    }

    public static int factorial(int n) {
        int sum = 0;
        if (n == 1) {
            return 1; // 递归出口：n=1时返回1
        } else {
            sum = n * factorial(n - 1); // 递归逻辑：n! = n × (n-1)!
        }
        return sum;
    }
}
练习 3：计算斐波那契数列第 n 个值

斐波那契数列规律：从第 3 项开始，每一项等于前两项之和（如 1, 1, 2, 3, 5, 8, 13...），递归出口为 n == 1 或 n == 2（前两项均为 1）。

public class RecursionTest3 {
    public static void main(String[] args) {
        int result = feibo(6);
        System.out.println(result); // 输出结果：8（第6项为8）
    }

    public static int feibo(int n) {
        int x = 0;
        if (n == 1 || n == 2) {
            return 1; // 递归出口：前两项均返回1
        } else {
            x = feibo(n - 1) + feibo(n - 2); // 递归逻辑：第n项 = 第n-1项 + 第n-2项
            return x;
        }
    }
}

三、数组算法：反转、排序与查找实战

数组是 Java 中最常用的数据结构之一，反转、冒泡排序、二分查找是数组操作的经典算法，需熟练掌握其逻辑与实现。

3.1 数组反转

需求：将数组中「对称索引位置的元素互换」（如 [1,2,3,4,5] 反转后为 [5,4,3,2,1]）。

public class ArrayReverse {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        FanZhuan(arr); // 调用反转方法
    }

    /**
     * 数组反转方法
     * @param arr 待反转的数组
     */
    public static void FanZhuan(int[] arr) {
        int arr1[] = new int[arr.length]; // 创建新数组存储反转后的数据
        for (int i = 0; i < arr.length; i++) {
            // 对称索引：原数组索引i 对应 新数组索引arr.length-1-i
            arr1[i] = arr[arr.length-1-i];
        }
        
        // 方式1：普通for循环打印反转后数组
        for (int i = 0; i < arr1.length; i++){
            System.out.println(arr1[i]); // 输出：5 4 3 2 1
        }

        // 方式2：增强for循环打印（更简洁）
        for (int i : arr1){
            System.out.println(i); // 输出：5 4 3 2 1
        }
    }
}

3.2 冒泡排序

冒泡排序核心逻辑：通过相邻元素的多次比较与交换，将最大元素逐步“冒泡”到数组末尾，每轮排序后，未排序区间的最大元素确定位置。

关键规律：
  • 排序轮数：arr.length - 1（n 个元素需 n-1 轮，最后一个元素无需排序）
  • 每轮比较次数：arr.length - 1 - i（i 为当前轮数，已排序的元素无需再比较）
public class BubbleSortDemo {
    public static void main(String[] args) {
        int[] arr = {3, 2, 1, 5, 4};
        bubbleSort(arr); // 调用冒泡排序方法
    }

    /**
     * 冒泡排序方法（升序）
     * @param arr 待排序的数组
     */
    public static void bubbleSort(int[] arr) {
        // 外层循环：控制排序轮数（共arr.length-1轮）
        for (int i = 0; i < arr.length; i++) { 
            // 内层循环：控制每轮比较次数（每轮减少i次，因i个元素已排序）
            for (int j = 0; j < arr.length - 1 - i; j++) {  
                int temp = 0;
                // 相邻元素比较：前元素 > 后元素则交换（升序逻辑）
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        
        // 增强for循环打印排序后数组
        for (int i : arr) {
            System.out.println(i); // 输出：1 2 3 4 5
        }
    }
}
排序过程示例（数组 [3,2,1,5,4]）：
  • 第 1 轮：[2,1,3,4,5]（比较 4 次，最大元素 5 冒泡到末尾）
  • 第 2 轮：[1,2,3,4,5]（比较 3 次，第二大元素 4 冒泡到倒数第二位）
  • 第 3 轮：无交换（比较 2 次，数组已有序）
  • 第 4 轮：无交换（比较 1 次，排序结束）

3.3 二分查找

二分查找（又称折半查找）是高效的查找算法，适用于「已排序的数组」，时间复杂度为 O(log n)（远优于线性查找的 O(n)）。

核心注意事项：
  1. 前提条件：必须作用于已排序数组（升序/降序需与比较逻辑匹配）
  2. 边界计算：
    • 中间索引：mid = left + (right - left)/2（避免 left + right 导致的整数溢出）
    • 循环条件：left <= right（包含等于，确保不遗漏最后一个元素）
  3. 范围调整：
    • 找到目标：立即返回 mid（索引）
    • 目标更大：left = mid + 1（向右缩小查找范围）
    • 目标更小：right = mid - 1（向左缩小查找范围）
  4. 终止条件：循环结束返回 -1（表示目标不存在）
  5. mid 更新：每次循环必须重新计算 mid（不能在循环外固定赋值）
public class BinarySearchDemo {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5}; // 二分查找必须用有序数组
        int index = midSort(arr, 5); // 查找目标值5
        if (index != -1) {
            System.out.println("目标值找到，索引为：" + index); // 输出：目标值找到，索引为：4
        } else {
            System.out.println("目标值不存在于数组中");
        }
    }

    /**
     * 二分查找方法（升序数组）
     * @param arr 已排序的数组
     * @param target 待查找的目标值
     * @return 目标值的索引（未找到返回-1）
     */
    public static int midSort(int[] arr, int target) {
        int left = 0; // 左边界索引
        int right = arr.length - 1; // 右边界索引

        // 先判断数组合法性（空数组或长度为0直接返回-1）
        if (arr.length == 0 || arr == null) {
            return -1;
        }
        
        // 循环查找：左边界 <= 右边界
        while (left <= right) {
            int mid = (left + right) / 2; // 计算中间索引
            if (arr[mid] == target) {
                return mid; // 找到目标，返回索引
            } else if (arr[mid] < target) {
                left = mid + 1; // 目标在右侧，调整左边界
            } else {
                right = mid - 1; // 目标在左侧，调整右边界
            }
        }
        return -1; // 循环结束未找到，返回-1
    }
}

3.4 对象数组

对象数组是「存储对象引用的数组」，数组中的每个元素都是对象的地址，而非对象本身。通过对象数组可批量管理多个对象。

需求：定义数组存储 3 个 Person 对象，并遍历获取属性值
1. Person 类（封装姓名、年龄属性）
public class Person {
    // 私有属性（封装）
    private String name;
    private int age;

    // 无参构造方法
    public Person() {
    }

    // 有参构造方法（用于初始化属性）
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter方法（获取私有属性值）
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    // Setter方法（修改私有属性值，可选）
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
2. 对象数组的创建与遍历
public class ObjectArrayDemo {
    public static void main(String[] args) {
        // 1. 创建对象数组（长度为3，存储3个Person对象）
        Person[] arr = new Person[3];
        
        // 2. 创建Person对象
        Person p1 = new Person("张三", 18);
        Person p2 = new Person("lisi", 19);
        Person p3 = new Person("wangwu", 20);
        
        // 3. 将对象引用存入数组
        arr[0] = p1;
        arr[1] = p2;
        arr[2] = p3;

        // 4. 遍历对象数组，获取属性值（需通过Getter方法）
        for (int i = 0; i < arr.length; i++) {
            // 直接打印数组元素：输出对象的地址（如com.code.Person@41629346）
            System.out.println(arr[i]);
            // 通过Getter方法获取属性值
            System.out.println(arr[i].getName() + arr[i].getAge()); 
        }
    }
}
输出结果：
com.code.day08.Person@41629346
张三18
com.code.day08.Person@4f3f5b24
lisi19
com.code.day08.Person@15aeb7ab
wangwu20

四、方法参数传递：基本类型 vs 引用类型

Java 中方法参数传递的核心规则是「值传递」，但基本类型和引用类型的传递效果不同，本质是因为两者在内存中的存储方式不同。

4.1 基本数据类型做方法参数传递

基本类型（如 int、double、boolean）存储的是「具体值」，传递时会复制一份值给方法参数，方法内部修改参数值不会影响原变量。

public class BasicParamDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("调用前：a=" + a + ", b=" + b); // 输出：调用前：a=10, b=20
        
        // 传递的是a和b的值副本，而非原变量
        method(a, b);
        
        System.out.println("调用后：a=" + a + ", b=" + b); // 输出：调用后：a=10, b=20（原变量未变）
    }

    private static void method(int a, int b) {
        a += 10; // a变为20（修改的是副本）
        b += 20; // b变为40（修改的是副本）
        System.out.println("方法内：a=" + a + ", b=" + b); // 输出：方法内：a=20,
JAVASE 数组相关知识
zdsxc_的博客
04-29 881
数组是相同类型数据的有序集合数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成其中每一个数据称作数组的一个元素，每个数组元素可以通过一个下标来进行访问。
专项训练【JavaSE（数组和列表）】
qq_45824565的博客
02-21 498
题目一 A.方便运算 B.方便存储 C.提高运算速度 D.减少存储空间 解析：选D A C，都是运算方面的好处 B，如果邻接表，还要存指针，并没有方便存储 D，不管是，邻接矩阵还是邻接表，都节省了空间 题目二 正确 错误 解析：正确 考察的将矩阵（下半个三角部分）的元素依次按照每行的元素添加到数组中，求的是A64前面有多少元素。 A00 A0...
2022-04-07 西安 javaSE(04) 可变参数、方法的重载和递归、数组、二维数组
m0_56799642的博客
04-07 594
方法的重载 在同一个类中（或者子父类继承关系中），出现了方法名相同,形参列表不同的现象 形参列表必须不同（至少满足以下一点） 形参列表中的数据类型不同 形参列表中形参个数不同 形参列表中数据类型的顺序不同 method((byte)123);会调用第一个形参为short的方法 public static void method(short a) { System.out.println("short");//byte首先提升为short .........
JavaSE学习笔记-方法+数组（3）
Never Give Up
01-07 191
目录 1.方法的定义： 2.方法的重载 3.命令行传递参数 4.可变长参数 5.递归： 6.数组 7.冒泡排序 1.方法的定义： java的方法是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法： 修饰符、返回值类型、方法名、参数类型、方法体. 修饰符 返回值类型 方法名（参数类型 参数名）{ ......................... 方法体 ...
[JavaSE] 03 方法和数组
maets906的博客
10-20 261
方法
javase：数组和方法
weixin_48595687的博客
07-13 238
1.方法的定义调用 2.方法重载 3.可变参数 4.递归 练习：控制写一个简易计算器 java数组 1.数组定义创建 2.数组使用for-each循环数组做方法入参数组做返回值 3.多维数组 将多维数组看做是它的元素是数组就可以！4.Arrays类 5.冒泡排序 6.稀疏数组...
数据结构与算法学习③(Hash hash算法的工程应用 递归 )
m0_46690280的博客
11-19 2005
HashHash散列表(Hash Table)概述散列函数面试实战亚马逊，微软最近面试题，242. 有效的字母异位词腾讯，高盛集团最近面试题，49. 字母异位词分组快慢指针解决链表问题876链表的中间节点剑指 Offer 22. 链表中倒数第k个节点 Hash 散列表(Hash Table) 概述 散列表(Hash Table)又名哈希表/Hash表，是根据键（Key）直接访问在内存存储位置值（Value）的数据结构，它是由数组演化而来的，利用了数组支持按照下标进行随机访问数据的特性；举例说明散列的思想及原
重学JavaSE 第6章 : 面向对象(上) 类和对象、方法的重载、可变参数、方法的值传递机制、封装、构造器、this、import关键字等
Guizy
07-31 1380
重温 类和对象、方法的重载、可变参数、方法的值传递机制、封装、构造器、this、import关键词等
Java基础入门笔记04——方法调用，方法重载，命令行参数，可变参数，多维数组，Arrays类，冒泡排序，矩阵的压缩存储
weixin_48751167的博客
11-14 335
JAVA基础04 方法 System.out.println()——类.对象.方法 out是标准输出对象 方法是语句的集合，用于执行一个功能——类似C语言中的函数 public class Demo01 { public static void main(String[] args) { //main就是一个方法————由java虚拟机调用 //void 是返回类型 int sum = add(1, 2); System.out.pri
今天我们来聊聊递归喝汽水问题
热门推荐
Qizhi_Hu的博客
06-26 1万+
用代码喝汽水的正确打开方式...
JavaSE面试必备知识点与解析
对于可变参数的理解和应用场景也是面试的重点。 面向对象是Java的核心，面试者需要阐述类和对象的关系，比较面向过程和面向对象编程的差异，清楚方法重载和重写的概念。同时，理解this和super关键字的作用，以及...
JavaSE面试题及其参考答案.doc
05-25
Java中的可变参数提供了一种方便的参数传递方式，可以传递任意数量的参数给方法。 面向对象编程是Java的核心，包括类和对象、继承、封装、多态等概念。类和对象是构成Java面向对象系统的基础。类是对象的模板，对象...
JavaSE实用Demo与算法总结：Java8新特性及文件操作
- BigDecimal：用于高精度计算的不可变的、任意精度的浮点数，常用于金融、科学计算等领域。 - TODO：other，这可能意味着还有其他数据操作的方法或类。 5. 文件操作 文件操作涉及到读写文件，Java提供了丰富的...
常见排序算法及Java实现
xike1024的博客
08-27 1448
常见排序算法及Java代码实现
SM4加密算法
简单点的博客
08-27 398
SM4加密算法
北斗导航 | RAIM算法改进方案及性能对比分析报告
最新发布
尘世冰封的专栏
08-30 574
多假设分组算法通过构建卫星子集组合实现故障检测与隔离，核心原理是将可见卫星划分为多个假设子集，对每个子集进行定位解算并比较结果一致性。
二分查找算法题（持续更新）
2301_79482961的博客
08-27 340
/求左端点while(left < right){ //细节一//细节2}else{}else{//求右端点//细节三left = mid;}else{
基于NXP iMXRT600音频算法开发方法
2401_89373706的博客
08-27 549
iMXRT600音频算法开发指南摘要： 环境搭建：准备iMXRT600开发板及音频I/O接口，安装MCUXpresso IDE和SDK工具包。 音频基础：掌握采样率、位数及PCM编码格式，合理配置参数。 数据采集与输出：通过I2S接口实现音频输入（麦克风）和输出（扬声器）功能。 算法开发：从基础音量调节到复杂算法（如降噪），可借助Speex等开源库优化移植。 调试优化：利用IDE调试工具验证功能，优化算法效率以降低CPU负载。 测试验证：通过Audacity等工具测试兼容性与稳定性，覆盖不同采样参数和设备。
LeetCode 136. 只出现一次的数字
qscfgjn的博客
08-30 181
除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。你必须设计并实现线性时间复杂度的算法来解决此问题，且该算法只使用常量额外空间。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值