Java函数式接口——渐进式学习

一、函数式接口的定义

函数式接口 （Functional Interface） 是Java 8引入的核心概念，它是指有且仅有一个抽象方法的接口（可包含默认方法和静态方法）。这种接口可以用Lambda表达式或方法引用来实现，是函数式编程在Java中的基础。

1. // 标准定义
2. @FunctionalInterface  // 编译期检查，可选但推荐
3. public interface MyFunction {
4.     String apply(int x);  // 唯一的抽象方法
6.     // 允许默认方法
7.     default void print(String msg) {
8.         System.out.println(msg);
9.     }
11.     // 允许静态方法
12.     static void log(String msg) {
13.         System.out.println("[LOG] " + msg);
14.     }
15. }

复制代码

二、渐进式学习——代码示例

2.1 阶段1：从匿名类到Lambda演化

1. public class EvolutionDemo {
2.     public static void main(String[] args) {
3.         List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
5.         // 【传统方式】匿名内部类
6.         names.forEach(new Consumer<String>() {
7.             @Override
8.             public void accept(String name) {
9.                 System.out.println(name);
10.             }
11.         });
13.         // 【方式1】Lambda完整语法
14.         names.forEach((String name) -> {
15.             System.out.println(name);
16.         });
18.         // 【方式2】Lambda简化（参数类型推导）
19.         names.forEach((name) -> System.out.println(name));
21.         // 【方式3】Lambda最简（单参数可省括号）
22.         names.forEach(name -> System.out.println(name));
24.         // 【方式4】方法引用（终极简化）
25.         names.forEach(System.out::println);
26.     }
27. }

复制代码

2.2 阶段2：Java内置的四大核心函数式接口精讲

1. Consumer - 消费型接口

1. @FunctionalInterface
2. public interface Consumer<T> {
3.     void accept(T t);
4. }

复制代码

作用：接收一个参数，不返回结果
示例：

1. // 打印字符串
2. Consumer<String> printer = s -> System.out.println(s);
3. printer.accept("Hello, Consumer!");
5. // 消费列表元素
6. List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
7. names.forEach(name -> System.out.println("Hello, " + name));

复制代码

2. Supplier- 供给型接口

1. @FunctionalInterface
2. public interface Supplier<T> {
3.     T get();
4. }

复制代码

作用：不接收参数，返回一个结果
示例：

1. // 生成随机数
2. Supplier<Double> randomSupplier = () -> Math.random();
3. System.out.println("Random: " + randomSupplier.get());
5. // 延迟初始化
6. Supplier<String> lazyString = () -> {
7.     System.out.println("Initializing...");
8.     return "Lazy Value";
9. };
10. System.out.println("Before get");
11. System.out.println(lazyString.get());

复制代码

3. Function - 函数型接口

1. @FunctionalInterface
2. public interface Function<T, R> {
3.     R apply(T t);
4. }

复制代码

作用：接收一个参数，返回一个结果
示例：

1. // 字符串转整数
2. Function<String, Integer> stringToInt = s -> Integer.parseInt(s);
3. int result = stringToInt.apply("123");
4. System.out.println("Result: " + result);
6. // 函数组合
7. Function<Integer, Integer> doubleIt = x -> x * 2;
8. Function<Integer, Integer> addOne = x -> x + 1;
9. Function<Integer, Integer> composed = doubleIt.andThen(addOne);
10. System.out.println("Composed: " + composed.apply(5)); // 输出: 11

复制代码

4. Predicate - 断言型接口

1. @FunctionalInterface
2. public interface Predicate<T> {
3.     boolean test(T t);
4. }

复制代码

作用：接收一个参数，返回布尔值
示例：

1. // 判断字符串是否为空
2. Predicate<String> isEmpty = s -> s == null || s.isEmpty();
3. System.out.println("Is empty: " + isEmpty.test("")); // true
5. // 过滤列表
6. List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
7. List<Integer> evenNumbers = numbers.stream()
8.     .filter(n -> n % 2 == 0)
9.     .collect(Collectors.toList());
10. System.out.println("Even numbers: " + evenNumbers); // [2, 4, 6]

复制代码

2.3 阶段3：自定义函数式接口实践

1. // 定义业务相关的函数式接口
2. @FunctionalInterface
3. interface OrderValidator {
4.     boolean validate(Order order);
5.    
6.     // 默认方法：组合验证
7.     default OrderValidator and(OrderValidator other) {
8.         return order -> this.validate(order) && other.validate(order);
9.     }
10. }
12. // 使用自定义接口
13. public class CustomFunctionalInterface {
14.     public static void main(String[] args) {
15.         List<Order> orders = createOrders();
16.         
17.         // 定义验证规则
18.         OrderValidator isActive = Order::isActive;
19.         OrderValidator isHighValue = o -> o.getAmount() > 1000;
20.         
21.         // 组合验证（利用默认方法）
22.         OrderValidator combined = isActive.and(isHighValue);
23.         
24.         // 应用验证
25.         orders.stream()
26.             .filter(combined::validate) // 方法引用
27.             .forEach(o -> System.out.println("Valid: " + o));
28.     }
29. }

复制代码

2.4 阶段4：方法引用与构造函数引用

1. public class ReferenceDemo {
2.     public static void main(String[] args) {
3.         List<String> names = Arrays.asList("Tom", "Jerry");
5.         // 1. 静态方法引用：类名::静态方法
6.         names.stream()
7.             .map(String::toUpperCase) // 等价于 s -> s.toUpperCase()
8.             .forEach(System.out::println);
10.         // 2. 实例方法引用：对象::实例方法
11.         String prefix = "Name: ";
12.         names.forEach(s -> System.out.println(prefix + s));
14.         // 3. 构造函数引用：类名::new
15.         Supplier<List<String>> listSupplier = ArrayList::new;
16.         List<String> newList = listSupplier.get();
18.         // 4. 数组构造函数引用：类型[]::new
19.         IntFunction<String[]> arrayCreator = String[]::new;
20.         String[] array = arrayCreator.apply(5); // 创建长度为5的数组
21.     }
22. }

复制代码

2.5 阶段5：Stream API中的函数式接口应用

1. public class StreamFunctionalDemo {
2.     public static void main(String[] args) {
3.         List<Employee> employees = Arrays.asList(
4.             new Employee("Alice", 8000, "Tech"),
5.             new Employee("Bob", 12000, "Tech"),
6.             new Employee("Charlie", 7000, "HR")
7.         );
9.         // 综合案例：分组、过滤、转换
10.         Map<String, List<String>> result = employees.stream()
11.             .filter(e -> e.getSalary() > 7500)  // Predicate
12.             .map(Employee::getName)             // Function
13.             .collect(Collectors.groupingBy(
14.                 name -> name.substring(0, 1)    // Function
15.             ));
17.         System.out.println(result); // {A=[Alice], B=[Bob]}
18.     }
19. }

复制代码

2.6 综合实战案例

1. // 构建一个函数式风格的订单处理系统
2. public class OrderProcessor {
3.     // 核心：用函数式接口定义可组合的业务规则
4.     private final Function<Order, Double> taxCalculator;
5.     private final Predicate<Order> validationRule;
6.     private final Consumer<Order> auditLogger;
8.     // 构造函数注入行为
9.     public OrderProcessor(Function<Order, Double> taxCalculator,
10.                          Predicate<Order> validationRule,
11.                          Consumer<Order> auditLogger) {
12.         this.taxCalculator = taxCalculator;
13.         this.validationRule = validationRule;
14.         this.auditLogger = auditLogger;
15.     }
17.     public void process(List<Order> orders) {
18.         orders.stream()
19.             .filter(validationRule)                    // 验证
20.             .peek(auditLogger)                         // 记录日志
21.             .map(order -> {                            // 计算税后价格
22.                 double tax = taxCalculator.apply(order);
23.                 order.setFinalPrice(order.getAmount() + tax);
24.                 return order;
25.             })
26.             .forEach(order -> System.out.println("处理完成: " + order));
27.     }
29.     public static void main(String[] args) {
30.         // 配置不同的业务规则
31.         OrderProcessor domesticProcessor = new OrderProcessor(
32.             order -> order.getAmount() * 0.1,   // 10%税
33.             Order::isActive,                     // 仅处理激活订单
34.             o -> System.out.println("审计: " + o.getId())
35.         );
37.         domesticProcessor.process(createOrders());
38.     }
39. }

复制代码

三、总结

在四大核心函数式函数式接口的基础上，还有BiFunction - 双参数转换、UnaryOperator - 一元操作、BinaryOperator - 二元操作。简单来说，UnaryOperator和BinaryOperator并非新的概念，而是两大核心函数式接口的“特化”或“简化版”。它们与四大核心函数接口的关系是包含与被包含的关系，而非并列关系。
接口类型方法签名用途示例Consumervoid accept(T t)消费数据forEachSupplierT get()提供数据延迟初始化FunctionR apply(T t)数据转换mapPredicateboolean test(T t)条件判断filterBiFunctionR apply(T t, U u)双参数转换合并操作UnaryOperatorT apply(T t)一元操作字符串处理BinaryOperatorT apply(T t1, T t2)二元操作数学运算

• Function和 BiFunction​ 是基础且通用的转换接口，适用于各种复杂的类型转换场景。
  
• UnaryOperator和 BinaryOperator​ 是前两者的特殊形式，专门用于输入输出类型一致的特定场景，使代码意图更明确。
  

如果有需要，也可以使用@FunctionalInterface注解来定制契合某个业务的函数式接口。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！