Java 8 引入了 Functional Interface (函数式接口) 概念，使得 Java 的代码风格更加简洁优雅。今天，我们就来看看如何巧妙利用这些函数式接口，使代码更具灵活性。

1. 函数式接口是什么？

函数式接口是只包含一个抽象方法的接口。它们可以与 lambda 表达式或方法引用配合使用，简化代码结构。例如，Runnable 就是一个简单的函数式接口。

Java 内置了一些常用的函数式接口，像 Function、Consumer、Supplier、Predicate 等，为我们提供了多种场景下的“标准化”接口。你还可以通过 @FunctionalInterface 注解创建自定义函数式接口。

2. Function：处理数据转化

Function<T, R> 接口用于接收一个输入参数并返回一个结果，非常适合数据的转换和映射操作。

假设我们有一个用户列表，需要从每个用户对象中提取用户名，可以使用 Function 实现：

Function<User, String> getUsername = User::getUsername;
List<String> usernames = users.stream()
                               .map(getUsername)
                               .collect(Collectors.toList());

Function 可以让数据转换逻辑更加清晰，并支持链式操作。例如，在转换后再进行某种操作：

Function<String, String> addPrefix = s -> "User: " + s;
List<String> result = usernames.stream()
                               .map(addPrefix.andThen(String::toUpperCase))
                               .collect(Collectors.toList());

3. Consumer：专注执行某种操作

Consumer<T> 接口表示接收一个参数但不返回结果的操作。适合用于打印、日志记录、数据存储等场景。

例如，我们可以用 Consumer 简化日志记录：

Consumer<String> logger = msg -> System.out.println("Log: " + msg);
usernames.forEach(logger);

我们甚至可以创建链式的 Consumer 来执行多个操作，例如同时打印和记录到文件：

Consumer<String> print = System.out::println;
Consumer<String> log = msg -> Files.write(logPath, msg.getBytes(), StandardOpenOption.APPEND);
usernames.forEach(print.andThen(log));

4. Supplier：延迟执行，惰性加载

Supplier<T> 接口没有输入参数，但返回一个结果，常用于懒加载或动态生成数据。

假设我们有个复杂对象，只在需要时才初始化，可以使用 Supplier：

Supplier<ExpensiveObject> lazyObject = () -> new ExpensiveObject();

这样，ExpensiveObject 只在调用 lazyObject.get() 时才会创建。这种方式常用于提升性能，尤其在创建代价高昂的对象时。

5. Predicate：灵活的条件判断

Predicate<T> 接口接收一个参数并返回布尔值，适合用于各种条件判断。假设你需要筛选出特定条件的数据，Predicate 就是绝佳选择。

例如，我们筛选出年龄大于 18 岁的用户：

Predicate<User> isAdult = user -> user.getAge() > 18;
List<User> adults = users.stream()
                          .filter(isAdult)
                          .collect(Collectors.toList());

更妙的是，Predicate 支持链式操作，可以通过 and、or、negate 等方法组合条件：

Predicate<User> isTeenager = isAdult.negate();
List<User> teenagers = users.stream()
                            .filter(isTeenager)
                            .collect(Collectors.toList());

6. 自定义函数式接口：定义独特的业务逻辑

有时，内置的接口不够用，我们可以通过 @FunctionalInterface 注解自定义接口。例如，实现一个双参数的接口 BiFunction，用于处理更复杂的业务逻辑：

@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);
}

Calculator addition = (a, b) -> a + b;
System.out.println(addition.calculate(10, 20)); // 输出 30

这种方式非常适合抽象特定业务逻辑，使代码更具可读性和复用性。

7. UnaryOperator和 BinaryOperator：简化同类型操作

如果需要进行相同类型的操作，可以使用 UnaryOperator<T> 和 BinaryOperator<T>。

例如，一个数值列表中所有元素增加 10：

UnaryOperator<Integer> addTen = x -> x + 10;
List<Integer> result = numbers.stream()
                              .map(addTen)
                              .collect(Collectors.toList());

这比使用 Function<T, T> 更直观，适合用于同类型的数据操作。

总结：

Java 的函数式接口不仅让代码更简洁，还带来了许多灵活的应用场景。从数据转换、条件判断到延迟加载，函数式接口赋予了 Java 全新的编程风格。掌握这些接口的应用技巧，你的代码会更具现代感！