Java 中函数作为参数传递方法详解

更新时间：2025年11月29日 10:31:08 作者：Geoking.

文章介绍了Java中函数式编程的概念,包括Lambda表达式、方法引用和函数式接口,通过这些特性,Java可以将函数作为参数传递,从而实现更灵活和简洁的代码,文章还列举了Java内置的函数式接口,并展示了它们在Stream API中的应用,感兴趣的朋友跟随小编一起看看吧

一、前言

在传统的 Java 开发中，我们习惯将数据作为参数传递给方法。
但从 Java 8 开始，Java 引入了 Lambda 表达式 和 方法引用，
让我们能够像在函数式语言中那样，把“函数（行为）”本身作为参数进行传递。

这种特性让 Java 更加灵活、简洁，也极大地推动了 函数式编程（Functional Programming） 在 Java 中的应用。

二、为什么要把函数作为参数传递？

在面向对象编程中，我们常常写这样的代码：

public void process(String input) {
    System.out.println(input.toUpperCase());
}

如果你想对 input 做不同的处理逻辑，比如转小写、反转、加前缀……
通常要写多个方法，或者在方法内部用 if/else。

但如果我们能将“处理逻辑”作为函数传入，就可以让方法更通用：

public void process(String input, Function<String, String> operation) {
    System.out.println(operation.apply(input));
}

于是我们就能这样灵活调用：

process("Java", s -> s.toUpperCase());    // 转大写
process("Java", s -> s.toLowerCase());    // 转小写
process("Java", s -> "Hello " + s);       // 加前缀

是不是非常优雅？这就是“函数作为参数传递”的威力。

三、实现函数传参的关键：函数式接口

在 Java 中，函数不是一等公民，不能直接像 Python 那样传递函数。
但 Java 通过 函数式接口（Functional Interface） 实现了类似功能。

函数式接口定义

函数式接口就是只包含一个抽象方法的接口。

例如：

@FunctionalInterface
interface MyOperation {
    void execute();
}

然后我们就可以传入一个 Lambda 表达式：

public class Demo {
    public static void main(String[] args) {
        doSomething(() -> System.out.println("Hello Lambda!"));
    }
    public static void doSomething(MyOperation op) {
        op.execute();  // 调用传入的函数
    }
}

输出：

Hello Lambda!

四、JDK 内置的函数式接口

Java 在 java.util.function 包中已经内置了大量常用函数式接口。

接口名	方法签名	功能说明
`Consumer<T>`	`void accept(T t)`	接收一个参数，无返回值
`Supplier<T>`	`T get()`	无参数，有返回值
`Function<T, R>`	`R apply(T t)`	接收参数并返回结果
`Predicate<T>`	`boolean test(T t)`	接收参数并返回布尔值

Consumer 示例

import java.util.function.Consumer;
public class ConsumerDemo {
    public static void main(String[] args) {
        processData("Java", s -> System.out.println("Hello, " + s + "!"));
    }
    public static void processData(String data, Consumer<String> action) {
        action.accept(data);
    }
}

输出：

Hello, Java!

Function 示例

import java.util.function.Function;
public class FunctionDemo {
    public static void main(String[] args) {
        transform("Lambda", s -> s.toUpperCase());
        transform("World", s -> "Hello " + s);
    }
    public static void transform(String data, Function<String, String> func) {
        String result = func.apply(data);
        System.out.println(result);
    }
}

输出：

LAMBDA
Hello World

Predicate 示例

import java.util.function.Predicate;
public class PredicateDemo {
    public static void main(String[] args) {
        check("OpenAI", s -> s.length() > 5);
        check("GPT", s -> s.startsWith("G"));
    }
    public static void check(String data, Predicate<String> condition) {
        System.out.println(condition.test(data));
    }
}

输出：

true
true

Supplier 示例

import java.util.function.Supplier;
public class SupplierDemo {
    public static void main(String[] args) {
        printValue(() -> "Hello from Supplier!");
    }
    public static void printValue(Supplier<String> supplier) {
        System.out.println(supplier.get());
    }
}

输出：

Hello from Supplier!

五、结合方法引用（::）的写法

当传入的 Lambda 只是调用某个已有方法时，可以用 方法引用 简化：

import java.util.List;
public class MethodRefDemo {
    public void print(String s) {
        System.out.println("Item: " + s);
    }
    public void printAll(List<String> list) {
        // 等价于 list.forEach(s -> this.print(s));
        list.forEach(this::print);
    }
    public static void main(String[] args) {
        new MethodRefDemo().printAll(List.of("Java", "Python", "C++"));
    }
}

输出：

Item: Java
Item: Python
Item: C++

六、Stream API 中的函数传参

函数式接口的最大用途之一，就是在 Stream API 中传递行为逻辑。

import java.util.List;
public class StreamExample {
    public static void main(String[] args) {
        List<String> names = List.of("Alice", "Bob", "Charlie", "David");
        names.stream()
             .filter(name -> name.length() > 3)     // 传入 Predicate
             .map(String::toUpperCase)              // 传入 Function
             .forEach(System.out::println);         // 传入 Consumer
    }
}

输出：

ALICE
CHARLIE
DAVID

这就是 Java 函数式编程的典型应用场景。

七、总结

概念	说明
函数式接口	只包含一个抽象方法的接口，用于支持 Lambda 表达式
Lambda 表达式	让你能像传递数据一样传递行为
方法引用 (`::`)	Lambda 的简写方式，可直接引用已有方法
常用接口	`Consumer`、`Supplier`、`Function`、`Predicate`
典型应用	Stream API、回调函数、异步任务等

八、参考资料

Java-函数作为参数的传递与使用

Python中将函数作为参数传递给函数

到此这篇关于Java 中函数作为参数传递详解的文章就介绍到这了,更多相关java函数作为参数传递内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Java 精炼解读数据结构的顺序表如何操作
程序中经常需要将一组数据元素作为整体管理和使用，需要创建这种元素组，用变量记录它们，传进传出函数等。一组数据中包含的元素个数可能发生变化，顺序表则是将元素顺序地存放在一块连续的存储区里，元素间的顺序关系由它们的存储顺序自然表示
2022-03-03
RabbitMQ消息丢失解决方案
把这篇文章主要为大家介绍了如何保证RabbitMQ消息不丢失的解决方发，分从从丢失的三种情况给大家介绍不同的解决方案，感兴趣的小伙伴可以参考阅读本文
2023-07-07
SpringBoot解决数据库时间和返回时间格式不一致的问题
这篇文章主要介绍了SpringBoot解决数据库时间和返回时间格式不一致的问题,文章通过代码示例和图文结合的方式讲解的非常详细,对大家的学习和工作有一定的帮助,需要的朋友可以参考下
2024-03-03
Java解决通信过程的中文乱码的问题
这篇文章主要介绍了 Java解决通信过程的中文乱码的问题的相关资料,需要的朋友可以参考下
2017-01-01
解释为什么Java中“1000==1000”为false而”100==100“为true
在日常编程中,我们经常遇到一些看似简单却隐藏着复杂逻辑的问题,这篇文章主要介绍了解释为什么Java中“1000==1000”为false而”100==100“为true,需要的朋友可以参考下
2024-01-01
SpringBoot接口访问频率限制的实现方式
接口访问频率限制是通过在一定时间内限制用户对接口的访问次数来实现的,在Spring Boot中,我们可以通过多种方式来实现接口的限流,如使用过滤器、拦截器或者借助第三方库,本文给大家讲解的非常详细,需要的朋友可以参考下
2024-07-07
探讨Java语言中那些修饰符
在java中常见的修饰符有：abstract(抽象的)、static(静态的)、public(公共的)、protected(受保护的)、private(私有的)、synchronized(同步的)、native(本地的)、transient(暂时的)、volatile(易失的)、final(不可改变的)。对java语言修饰符感兴趣的朋友一起看看吧
2016-11-11
轻松掌握Java模板模式
这篇文章主要帮助大家轻松掌握Java模板模式,具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2016-09-09
Spring Boot 自动装配原理及 Starter 实现原理解析
SpringBoot通过@SpringBootApplication注解简化了依赖引入和配置,该注解包括@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan三部分,感兴趣的朋友跟随小编一起看看吧
2024-09-09
Java访问修饰符public、private、protected及默认访问权限详解
这篇文章主要介绍了Java访问修饰符public、private、protected及默认访问权限的相关资料,每种修饰符都有其特定的使用场景,文中通过代码介绍的非常详细,需要的朋友可以参考下
2025-01-01