Java编程常用函数深入精讲教程（附案例源码）

原创 已于 2025-07-26 10:27:24 修改 · 370 阅读 · 5 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
Java

当前文章被收录于：

Java
1 篇文章 0 人学习
订阅专栏 查看详情
于 2025-07-26 10:26:54 首次发布

Java编程常用函数深入精讲教程（附案例源码）

一、函数基础概念

1. 函数组成要素

public class FunctionBasics {
    
    // 访问修饰符：public（公开访问）
    // 静态修饰符：static（类方法）
    // 返回类型：int（返回整数）
    // 函数名：calculateSum（动词+名词）
    // 参数列表：(int a, int b) - 形式参数
    public static int calculateSum(int a, int b) {
        int result = a + b;  // 函数体：执行计算
        return result;       // 返回值：返回计算结果
    }

    public static void main(String[] args) {
        int num1 = 10;  // 实际参数1
        int num2 = 20;  // 实际参数2
        
        // 函数调用：使用实际参数
        int sum = calculateSum(num1, num2);
        System.out.println("计算结果: " + sum);  // 输出：计算结果: 30
    }
}

2. 参数传递机制

public class ParameterPassing {
    
    // 值传递示例（基本数据类型）
    public static void modifyValue(int value) {
        value *= 2;  // 修改形参值
        System.out.println("函数内修改值: " + value);  // 输出：20
    }
    
    // 引用传递示例（对象类型）
    public static void modifyArray(int[] arr) {
        arr[0] = 100;  // 修改数组元素
        System.out.println("函数内数组: " + Arrays.toString(arr));  // 输出：[100, 2, 3]
    }

    public static void main(String[] args) {
        // 值传递测试
        int num = 10;
        modifyValue(num);
        System.out.println("main函数值: " + num);  // 输出：10（原始值未变）
        
        // 引用传递测试
        int[] numbers = {1, 2, 3};
        modifyArray(numbers);
        System.out.println("main函数数组: " + Arrays.toString(numbers));  // 输出：[100, 2, 3]
    }
}
二、函数分类精讲

1. 递归函数

public class RecursionDemo {
    
    // 递归计算阶乘
    // 时间复杂度：O(n)  空间复杂度：O(n)（调用栈深度）
    public static int factorial(int n) {
        if (n < 0) throw new IllegalArgumentException("负数无阶乘");  // 参数校验
        if (n == 0 || n == 1) return 1;  // 递归基线条件
        return n * factorial(n - 1);      // 递归调用
    }
    
    // 递归生成斐波那契数列
    // 时间复杂度：O(2^n)（指数级，实际应用需优化）
    public static int fibonacci(int n) {
        if (n <= 0) return 0;          // 处理非法输入
        if (n == 1 || n == 2) return 1;  // 基线条件
        return fibonacci(n-1) + fibonacci(n-2);  // 双递归调用
    }

    public static void main(String[] args) {
        System.out.println("5的阶乘: " + factorial(5));    // 输出：120
        System.out.println("斐波那契第7项: " + fibonacci(7)); // 输出：13
    }
}

2. 高阶函数（函数作为参数）

import java.util.function.Function;

public class HigherOrderFunctions {
    
    // 接受函数作为参数
    public static Integer operation(Function<Integer, Integer> func, int value) {
        return func.apply(value);  // 执行传入的函数
    }
    
    // 返回函数
    public static Function<Integer, Integer> getMultiplier(int factor) {
        return x -> x * factor;  // 返回lambda表达式（函数）
    }

    public static void main(String[] args) {
        // 1. 函数作为参数
        Integer doubled = operation(x -> x * 2, 5);  // 传入lambda表达式
        System.out.println("双倍值: " + doubled);  // 输出：10
        
        // 2. 函数工厂模式
        Function<Integer, Integer> tripler = getMultiplier(3);
        System.out.println("三倍值: " + tripler.apply(7));  // 输出：21
    }
}
三、经典算法函数实现

1. 排序算法

import java.util.Arrays;

public class SortingAlgorithms {
    
    // 快速排序（分治策略）
    // 时间复杂度：平均O(n log n)，最差O(n²)
    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pi = partition(arr, low, high);  // 获取分区点
            quickSort(arr, low, pi - 1);  // 递归排序左分区
            quickSort(arr, pi + 1, high); // 递归排序右分区
        }
    }
    
    private static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];  // 选择最右元素作为基准
        int i = low - 1;        // 小于基准的指针
        
        for (int j = low; j < high; j++) {
            if (arr[j] < pivot) {
                i++;
                // 交换元素
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        
        // 将基准放到正确位置
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;
        return i + 1;
    }

    // 测试排序
    public static void main(String[] args) {
        int[] data = {10, 80, 30, 90, 40, 50, 70};
        System.out.println("排序前: " + Arrays.toString(data));
        
        quickSort(data, 0, data.length - 1);
        System.out.println("快速排序后: " + Arrays.toString(data));
    }
}

2. 查找算法

public class SearchAlgorithms {
    
    // 二分查找（要求有序数组）
    // 时间复杂度：O(log n)
    public static int binarySearch(int[] arr, int target) {
        int left = 0;
        int right = arr.length - 1;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;  // 防止整数溢出
            
            if (arr[mid] == target) {
                return mid;  // 找到目标
            } else if (arr[mid] < target) {
                left = mid + 1;  // 搜索右半区
            } else {
                right = mid - 1; // 搜索左半区
            }
        }
        return -1;  // 未找到
    }
    
    // 线性查找（通用）
    // 时间复杂度：O(n)
    public static int linearSearch(int[] arr, int target) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) return i;
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] sortedData = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91};
        System.out.println("二分查找位置: " + binarySearch(sortedData, 23));  // 输出：5
        
        int[] unsortedData = {45, 12, 78, 23, 56, 89, 34};
        System.out.println("线性查找位置: " + linearSearch(unsortedData, 56)); // 输出：4
    }
}
四、实用工具函数

1. 字符串处理

public class StringUtils {
    
    // 反转字符串
    public static String reverse(String input) {
        return new StringBuilder(input).reverse().toString();  // 使用StringBuilder高效反转
    }
    
    // 统计字符出现次数
    public static int countCharOccurrences(String str, char target) {
        int count = 0;
        for (char c : str.toCharArray()) {
            if (c == target) count++;
        }
        return count;
    }
    
    // 检查回文（忽略大小写和空格）
    public static boolean isPalindrome(String str) {
        String cleanStr = str.replaceAll("\\s", "").toLowerCase();
        int left = 0, right = cleanStr.length() - 1;
        while (left < right) {
            if (cleanStr.charAt(left++) != cleanStr.charAt(right--)) 
                return false;
        }
        return true;
    }

    public static void main(String[] args) {
        System.out.println("反转结果: " + reverse("Java"));  // avaJ
        System.out.println("字符统计: " + countCharOccurrences("programming", 'm')); // 2
        System.out.println("回文检测: " + isPalindrome("A man a plan a canal Panama")); // true
    }
}

2. 数学计算

public class MathUtils {
    
    // 计算最大公约数（欧几里得算法）
    public static int gcd(int a, int b) {
        if (b == 0) return Math.abs(a);  // 处理负数
        return gcd(b, a % b);  // 递归求解
    }
    
    // 矩阵乘法
    public static int[][] matrixMultiply(int[][] A, int[][] B) {
        int rowsA = A.length;
        int colsA = A[0].length;
        int colsB = B[0].length;
        
        if (colsA != B.length) 
            throw new IllegalArgumentException("矩阵维度不匹配");
        
        int[][] result = new int[rowsA][colsB];
        
        for (int i = 0; i < rowsA; i++) {
            for (int j = 0; j < colsB; j++) {
                for (int k = 0; k < colsA; k++) {
                    result[i][j] += A[i][k] * B[k][j];  // 点积计算
                }
            }
        }
        return result;
    }

    public static void main(String[] args) {
        System.out.println("GCD(48, 18): " + gcd(48, 18));  // 6
        
        int[][] matrixA = {{1, 2}, {3, 4}};
        int[][] matrixB = {{5, 6}, {7, 8}};
        int[][] product = matrixMultiply(matrixA, matrixB);
        System.out.println("矩阵乘法结果: " + Arrays.deepToString(product)); 
        // 输出：[[19, 22], [43, 50]]
    }
}
五、函数设计最佳实践

1. 函数设计原则

public class BestPractices {
    
    // 好示例：单一职责，清晰命名
    public static double calculateCircleArea(double radius) {
        validateRadius(radius);  // 参数校验
        return Math.PI * radius * radius;  // 明确计算
    }
    
    private static void validateRadius(double radius) {
        if (radius <= 0) 
            throw new IllegalArgumentException("半径必须为正数");
    }
    
    // 避免：过长函数（>30行）
    // 避免：副作用（修改外部状态）
    public static int pureFunctionExample(int a, int b) {
        // 无副作用，输出仅依赖输入
        return a * b + (a + b);
    }
    
    // 文档注释示例
    /**
     * 计算身体质量指数(BMI)
     * 
     * @param weight 体重(千克)
     * @param height 身高(米)
     * @return BMI值
     * @throws IllegalArgumentException 参数非法时抛出
     */
    public static double calculateBMI(double weight, double height) {
        if (weight <= 0 || height <= 0) 
            throw new IllegalArgumentException("参数必须为正数");
        return weight / (height * height);
    }
    
    // 函数式接口应用
    public static void processNumbers(int[] numbers, IntConsumer processor) {
        for (int num : numbers) {
            processor.accept(num);  // 对每个元素执行操作
        }
    }

    public static void main(String[] args) {
        // 使用函数式接口
        int[] values = {1, 2, 3, 4, 5};
        processNumbers(values, n -> System.out.println("处理值: " + n * 2));
    }
}
六、性能优化技巧

1. 递归优化（记忆化）

import java.util.HashMap;
import java.util.Map;

public class RecursionOptimization {
    
    // 传统斐波那契（效率低）
    public static long fibNaive(int n) {
        if (n <= 1) return n;
        return fibNaive(n-1) + fibNaive(n-2);
    }
    
    // 使用记忆化优化
    private static Map<Integer, Long> memo = new HashMap<>();
    
    public static long fibMemoized(int n) {
        if (n <= 1) return n;
        if (memo.containsKey(n)) return memo.get(n);  // 返回缓存结果
        
        long result = fibMemoized(n-1) + fibMemoized(n-2);
        memo.put(n, result);  // 缓存计算结果
        return result;
    }
    
    // 迭代法（最佳性能）
    public static long fibIterative(int n) {
        if (n <= 1) return n;
        
        long a = 0, b = 1;
        for (int i = 2; i <= n; i++) {
            long temp = a + b;
            a = b;
            b = temp;
        }
        return b;
    }

    public static void main(String[] args) {
        int n = 45;
        
        long start = System.currentTimeMillis();
        System.out.println("记忆化结果: " + fibMemoized(n));
        System.out.println("耗时: " + (System.currentTimeMillis()-start) + "ms");
        
        start = System.currentTimeMillis();
        System.out.println("迭代结果: " + fibIterative(n));
        System.out.println("耗时: " + (System.currentTimeMillis()-start) + "ms");
    }
}
七、函数调试技巧
public class DebuggingTechniques {
    
    // 使用断言验证中间结果
    public static double calculateDiscount(double price, double rate) {
        assert price > 0 : "价格必须为正数";  // 启用断言需加VM参数：-ea
        assert rate >= 0 && rate <= 1 : "折扣率应在0-1之间";
        
        double discounted = price * (1 - rate);
        System.out.println("折扣计算中间值: " + discounted);  // 临时输出
        
        // 条件断点示例：当discounted < 50时暂停
        return discounted;
    }
    
    // 日志调试
    public static void processData(int[] data) {
        System.out.println("开始处理数组，长度: " + data.length);
        
        for (int i = 0; i < data.length; i++) {
            // 使用日志记录关键步骤
            if (data[i] < 0) {
                System.err.println("警告：发现负数索引 " + i);
            }
            data[i] *= 2;
        }
        
        System.out.println("处理完成: " + Arrays.toString(data));
    }

    public static void main(String[] args) {
        calculateDiscount(100, 0.2);  // 正常调用
        // calculateDiscount(-50, 0.3);  // 触发断言
        
        processData(new int[]{1, -2, 3, 0, 5});
    }
}

划重点！！！！！！

  1. 函数设计原则：

    • 单一职责（一个函数只做一件事）
    • 合理命名（动词+名词，如calculateTax）
    • 参数控制（≤5个参数）
    • 避免副作用（减少修改外部状态）

  2. 性能考量：

    • 递归函数需注意栈溢出风险
    • 时间复杂度敏感场景避免嵌套循环
    • 大数据处理优先选择迭代而非递归

  3. 代码可读性：

    • 添加清晰的文档注释（使用Javadoc）
    • 保持函数长度适中（20-30行）
    • 使用工具函数封装重复逻辑

  4. 异常处理：

    • 函数开头进行参数校验
    • 使用明确的异常类型
    • 避免在函数内吞没异常

所有案例均基于Java 17，可直接复制使用。建议通过修改参数、添加边界测试和性能分析来深化理解。实际开发中应结合具体场景选择合适实现方式。

标签
#算法
百看不如一练，55个Java练手项目（附源码+视频教程），全都在这里了
m0_70615468的博客
09-21 8289
于是，我熬了几个通宵，终于整理出了55个培训机构内部都在用Java练手项目【附源码+视频教程】。这些例子都很简单实用，非常适合初学者用来练习。大家也可尝试根据项目的目的及提示，自己构建解决方法，提高编程水平。我们都知道，不管学习那门语言最终都要做出实际的东西来，而对于编程而言，这个实际的东西当然就是项目啦，不用我多说大家都知道学编程语言做项目的重要性。项目领取方式：评论区留言或主动给我打个招呼，我都会回复的~~~支持作者的同时，便于自己下次更方便地找到叭！贪多嚼不烂，大家选择几套自己感兴趣的项目学习即可。
深入学习编程的案例源码分析
weixin_30591519的博客
09-19 2614
本文还有配套的精品资源，点击获取 简介：源码是软件开发的灵魂，展示了程序设计与实现的核心。本文章将深入探讨案例源码在教学、研究和调试中的应用，通过实例学习编程或技术的应用。源码涵盖所有编程语言的原始代码，包括但不限于Java、Python、C++、JavaScript等。文章中提供的压缩包包含一系列编程实例，如Web开发、移动应用、游戏开发、数据分析等，这些实例有助于理解代...
Java编程实战：140个实用源码实例精讲
weixin_42405592的博客
09-29 1335
本文还有配套的精品资源，点击获取 简介：本压缩包提供140个精选Java编程实例，覆盖从基础到进阶的各个方面，包括算法、模块功能、控制台及GUI应用、网络编程等。实例不仅包括代码，还附加注释和学习资源，方便学习者深入理解Java编程语言。文件还包含“下载及使用说明.txt”，指导初学者解压和运行代码，以及“更多Java资料学习.url”，链接至扩展学习资源。此外，“jsym...
【免费下载】 Java程序设计案例教程（第2版）资源下载
gitblog_09745的博客
10-16 1577
Java程序设计案例教程（第2版）资源下载 【下载地址】Java程序设计案例教程第2版资源下载 Java程序设计案例教程（第2版）资源下载本仓库提供《Java程序设计案例教程（第2版）》的相关资源下载，包括PPT课件、工作任务源码、例题源码以及习题答案及源码 ...
视频教程-物联网之java实现（springboot + netty + 心跳，附完整源码）-Java
weixin_33611578的博客
05-28 1538
物联网之java实现（springboot + netty + 心跳，附完整源码） ...
Java编程入门与实践：初学者源码教程
weixin_42509720的博客
11-08 1209
本文还有配套的精品资源，点击获取 简介：这份教程为Java初学者提供丰富的源码实例，帮助他们从基础开始掌握Java编程语言。教程包括在MyEclipse环境下的项目源码和一个纯代码版本，以适应不同的学习环境。初学者将学习Java的基础语法、面向对象编程的核心概念，以及如何在MyEclipse中进行类的创建和管理。同时，教程也覆盖了异常处理、集合框架、IO流、多线程和网络编程...
Java 函数式编程（常用接口）
琅琊之榜
07-14 542
本文主要介绍一下常用的接口及用法，先来看一个表格：本文主要选取几个常用的：Supplier、Consumer、Function、Predicate在此之前，再来了解一下@FunctionalInterface注解。
2022最新微信小程序商城搭建教程（附源码）
热门推荐
qq_38082146的博客
03-14 4万+
一、微信小程序商城环境搭建 参考教程：https://blog.csdn.net/u012888052/article/details/79623229 另外，因为程序涉及微信登录功能，还需要自己注册个测试账号，相关地址：https://developers.weixin.qq.com/sandbox 里面的AppID、AppSecret，后面需要配置到java后台配置文件中。 二、技术栈 css：略 javascript：略 axios：一个基于 promise 的 HTTP 库，可以用在浏
Java常用函数式编程接口
Armyyyyy丶的博客
06-22 805
一、函数式编程接口 Java中的函数式接口一共有四种，其都被注解@FunctionalInterface注释，表明这是一个函数式接口： 消费型接口（Consumer<T>）：接口方法void accept(T t)，参数T，无返回值； 供给型接口（Supplier<T>）：接口方法T get()，返回T类型返回值； 函数型接口（Function<T, R>）：接口方法R apply(T t)，入参为T类型，返回R类型返回值； 断言型接口（Predicate&lt
java 扫雷游戏源码案例项目
guangxiaove的专栏
02-03 1万+
代码如下 import java.awt.*; import javax.swing.*; //图形计数器JCounter三位 class JCounter extends JPanel { private static final long serialVersionUID = 1L; private ImageIcon [] numSet = { new
Java并发编程原理精讲 视频教程 下载
06-23 955
│ 11 对象属性原子更新器AtomicReferenceFieldUpdater的使用要求.mp4。│ 10 对象属性原子更新器AtomicReferenceFieldUpdater的问题.mp4。│ 06 AtomicReferenceArray的原子操作.mp4。│ 05 CyclicBarrier的底层实现原理-源码分析.mp4。│ 07 AtomicReference的原子操作.mp4。
Flink源码精讲系列开篇—源码编译
05-18 717
大家好，我是老兵。五月将开启一个新系列—Flink源码精读。讲解内容以一个运行程序为切入点，剖析Flink任务提交->task任务执行本期为Flink源码精读系列第一期—Flink源码编译，内容包含Flink源码下载、编译，作为精讲系列的开篇。话不多说，我们开始。
Java中的函数式编程
程序员伊成
09-30 781
使用Consumer作为示例，它是一个函数式接口，包含一个抽象方法accept，这个方法只有输入而无输出也就是说这个方法无返回值。//JDK1.8版本之前的做法@Override//调用方法这里可以打印出3.// 1. Consumer只有一个入参，没有出参// 第一种写法(有且只有一个入参)// 第二种写法// 第三种写法// 调用上面的con、con1、con2这个Consumer对象的引用照样可以打印出3.
《Offer来了：Java面试核心知识点精讲》大纲
Shipley_Leo的博客
06-04 1058
《Offer来了：Java面试核心知识点精讲》大纲
高薪程序员&Java面试题精讲系列汇总
一一哥
09-24 3732
因为CSDN没有分类归纳博客的功能，所以特写本帖汇总《高薪程序员面试题精讲系列教程》，方便大家查阅！希望各位小伙伴，可以从我的拙作中能对Java的高频面试题有所掌握，也希望各位可以多给与指教！目前本系列文章持续更新中，敬请关注...... 如果你觉得本系列博文对你有帮助，请给个 点赞评论 吧，手写博文不易，一篇文章可能得花一两天的时间才能写好，你的支持是我坚持下去的动力！ 本系列面试题涵盖的内容如下所示： 面试题系列文章链接： 高薪程序员&面试题精讲系列01之开篇介绍 高薪程序员&a.
Java编程题集：50题精讲及源码
weixin_35756624的博客
07-17 941
Java允许程序员定义自己的异常类，自定义异常类通常继承自Exception或其子类。在某些情况下，使用标准异常类无法准确描述异常的情况，或者需要额外的信息来描述错误情况，这时自定义异常就显得非常有用。自定义异常类的创建遵循标准的Java类创建规则，但通常会包含一些额外的信息，如错误代码、详细错误信息等。下面是一个简单的自定义异常类的例子：使用自定义异常类时，可以在可能抛出异常的地方通过throw关键字抛出它。
Java编程入门练习题【附源码】
weixin_52721608的博客
09-02 3586
其中，上半部分菱形是通过两个嵌套的循环来打印的，第一个循环控制行数，第二个循环控制每一行中的空格和星号个数。通过完成这些练习题，你将学会如何使用Java编写简单的程序，处理输入和输出，以及利用常见的数据结构和算法。然后，它检查是否存在多于一个奇数次出现的字符，如果存在，则说明不是回文排列。这些练习题的难度逐渐增加，从简单的开始，逐步引导您掌握更多复杂的概念和技术。无论你是想要巩固基础知识，提高编程技能，还是准备进一步学习Java的高级主题，这些练习题都会给你提供一个良好的起点。类来进行字符串的加密。
【函数式编程实战】(一)Java演变与函数式编程
小明的Java问道之路
07-11 3750
Java8函数式编程实战开篇暴击，电商多重优惠核销代码初探
【题解】LC：卷积（Convolution (Mod $2^{64}$)）
最新发布
Isaac Regulus的博客
08-03 303
拆分系数 ntt
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

十一剑的CS_DN博客

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值