Java函数式接口，一文彻底剖析！

发表于 更新于 分类于 阅读次数： 本文字数： 9.9k 阅读时长 ≈ 9 分钟

嗨，你好，我是猿java

自从 Java 8 引入函数式编程后，给很多 Java 程序员带来了福音，函数式编程是一种专注于使用函数来创建清晰简洁的代码的范式，它不像传统的命令式编程那样修改数据和维护状态，而是将函数视为一等公民。这样就可以将它们分配给变量，作为参数传递，并从其他函数返回，这种方法可以使代码更易于理解和推理。

Java为什么要引入函数式编程？

近年来，函数式编程因其能够帮助管理复杂性而越来越受欢迎，尤其是在大型应用程序中，它强调不变性，避免副作用，并以更可预测和模块化的方式处理数据，这样可以更轻松地测试和维护代码。

Java 是一种典型的面向对象语言，为什么会在 Java 8 中引入函数式编程特性？主要原因有以下几点：

  • 简化代码：函数式编程可以减少样板代码，使代码更简洁，从而更易于维护和更好的可读性。
  • 并发性和并行性：函数式编程与现代多核架构配合良好，可实现高效的并行处理，而无需担心共享状态或副作用。
  • 表现力和灵活性：通过采用函数式接口和 Lambda 表达式，Java 获得了更具表现力的语法，使我们能够编写灵活且适应性强的代码。

在 Java 语言中，函数式编程主要围绕着以下几个关键概念：

  • Lambda 表达式：在需要提供函数接口的任何地方使用这些紧凑函数。它们有助于减少样板代码。
  • 方法引用：这些是引用方法的简写方式，使代码更加简洁和可读。
  • 函数接口：这些是具有单个抽象方法的接口，非常适合 Lambda 表达式和方法引用。常见示例包括 Predicate、Function、Consumer、Supplier 和 Operator。

函数式编程的优缺点

Java 中的函数式编程给开发带来了许多便利，但同时也有缺点和挑战，下面整理了一些主要的优缺点：

优点

提高了代码的可读性

由于使用 Lambda 表达式和方法引用，函数代码往往非常简洁，从而减少了样板代码并简化了代码维护。对不可变性的关注（即数据结构在创建后保持不变）有助于减少副作用，并防止因状态意外更改而导致的错误。

与并发和并行的兼容性

由于函数式编程促进了不可变性，因此操作可以并行运行，而不会出现数据不一致或竞争条件的常见风险，这使得代码更适合多线程环境。

模块化和可重用性

函数式编程还促进了模块化和可重用性，由于函数是一等公民，我们可以创建小的、可重用的组件，从而产生更简洁、更易于维护的代码。

降低了复杂性

函数式编程中的抽象降低了整体复杂性，使我们能够专注于基本逻辑，而不必担心实现细节。

缺点

学习难度大

函数式编程的学习曲线可能很陡峭，特别是对于习惯于面向过程或面向对象编程的人来说，由于高阶函数和不变性等概念，我们的思维方式可能要发生显著的变化。

由于涉及抽象，调试函数代码也可能具有挑战性，理解复杂的 Lambda 表达式可能需要更深入地了解函数概念。

性能开销

性能开销是函数式编程的另一个问题，尤其是由于函数式编程中频繁的对象创建和附加函数调用，这可能会影响资源受限环境中的性能。

兼容性问题

与旧系统或库的集成可能会出现兼容性问题，因为它们可能不是为函数式编程设计的，从而导致集成困难。

灵活性

最后，函数式编程对不可变性和无副作用函数的关注可能会降低在需要可变性或复杂对象操作的场景中的灵活性。

总的来说，虽然函数式编程提供了显著的好处，如提高可读性和更容易的并发性，但它也带来了挑战，因此我们需要同时考虑这些优缺点，从而更好的把握函数式编程是否适应当前的 Java 应用程序。

@FunctionalInterface

Java 是如何定义函数式接口的？

下图为 @FunctionalInterface 在 JDK中源码的具体信息：

img.png

通过上述源码，我们可以得到以下信息：

  • @FunctionalInterface 注解位于 java.lang 包下，它是 Java 中一个特殊的标记，使接口成为函数式接口，使得它可以很好地用作 Lambda 表达式或方法引用的目标。

  • 在函数式接口中，有且只能有一个抽象方法，如果在接口中添加更多的抽象方法，编译器将生成错误，从而确保函数接口的完整性。

  • 函数式接口是 Java 支持函数式编程的核心，它们允许我们通过使用 Lambda 表达式、减少样板代码和促进可重用性来编写更简洁、更简洁的代码。

  • 函数式接口中允许存在 default方法，因为它不是抽象的，这也就意味函数式接口中可以存在多个方法，但是只能有一个抽象方法。

  • @FunctionalInterface 注解只能应用在接口上，不能应用于注解类型、枚举或类。

  • 另外，有些接口尽管它没有 @FunctionalInterface 注解，然而它只有一个抽象方法，因此该接口本质上也是函数式接口，因此 @FunctionalInterface 注解并不是必须的，但是增加该注释是一种很优雅的行为，因为它提高了代码的可读性，强制执行约束，并帮助其他人理解我们的意图，有助于提高代码库的可维护性和一致性。

函数式接口的使用

Java 的函数式接口有很多丰富的使用方式，这里主要从自定义函数式接口和内建函数式接口两个大方向进行分析。

img.png

自定义函数式接口

从上文的讲解我们可以知道：Java 的函数式接口本质上只有一个抽象方法。因此，我们可以利用这个特征来设计一个简单的计算器示例，接收两个整数入参并返回算术运算的结果。

为了实现这一点，我们定义一个名为 Calculator 的函数接口，并且包含一个 operate() 抽象方法，示例代码如下：

1
2
3
4
@FunctionalInterface
interface Calculator {
    int operate(int a, int b);
}

在上述示例中，Calculator 接口增加了 @FunctionalInterface注解，它清晰地表明 Calculator 是函数式接口，强调它应该只包含一个抽象方法 operate()。

operate() 方法 ，它接受两个整数入参并返回一个整数结果，通过这个函数接口，我们可以使用 Lambda 表达式创建不同的算术运算，比如加法、减法、乘法和除法，示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
@Test
void operateTest() {
    // 使用 Lambda 定义操作
    Calculator add = (a, b) -> a + b;      // 加法
    Calculator subtract = (a, b) -> a - b; // 减法
    Calculator multiply = (a, b) -> a * b; // 乘法
    Calculator divide = (a, b) -> a / b;   // 除法
    // 验证结果
    assertEquals(15, add.operate(10, 5));
    assertEquals(5, subtract.operate(10, 5));
    assertEquals(50, multiply.operate(10, 5));
    assertEquals(2, divide.operate(10, 5));
}

在 operateTest 这个测试方法中，我们首先使用 Calculator 为加减乘除 4个运算定义了 Lambda 表达式，然后使用断言来验证 operate() 方法的算术运算结果与预期值是否匹配。

通过这个示例，我们可以使用自定义函数式接口很灵活的定义 Lambda表达式，实现函数式编程。

Java内建函数式接口

从 Java 8 开始， 在 java.util.function 包里面提供了很多内置的函数接口，下面列举了几个最常见的内置函数式接口以及它们的典型用例和代码示例：

Predicate<T>

Predicate<T> 表示接受 T 类型的输入并返回布尔值的函数，通常用于筛选和条件检查。源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
@FunctionalInterface
public interface Predicate<T> {
  /**
   * Evaluates this predicate on the given argument.
   *
   * @param t the input argument
   * @return {@code true} if the input argument matches the predicate,
   * otherwise {@code false}
   */
    boolean test(T t);
    
    // default methods
}

使用举例：

  • 检查数字是否为偶数
  • 根据长度筛选字符串列表
  • 验证用户输入

如下代码，Predicate<Integer> 被定义为 isEven，它检查一个数是否是偶数。然后，我们使用 filter 方法和 isEven 谓词来筛选出偶数，并将结果收集到一个新的列表中。

1
2
3
4
5
6
7
8
9
10
11
12
13
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class PredicateExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Predicate<Integer> isEven = n -> n % 2 == 0;
        List<Integer> evenNumbers = numbers.stream().filter(isEven).collect(Collectors.toList());
        System.out.println("Even numbers: " + evenNumbers);
    }
}

Function<T, R>

Function<T, R> 表示函数接受 T 类型的输入并返回 R 类型的结果，通常用于转换或映射操作。源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
@FunctionalInterface
public interface Function<T, R> {
  /**
   * Applies this function to the given argument.
   *
   * @param t the function argument
   * @return the function result
   */ 
  R apply(T t);
  
  // default methods
}

使用举例：

  • 将字符串转换为大写
  • 将员工对象映射到其工资
  • 将字符串解析为整数

如下代码，Function<Integer, Integer> 被定义为 square，它计算一个整数的平方。我们使用 map 方法和 square 函数将所有整数转换为它们的平方，并将结果收集到一个新的列表中。

1
2
3
4
5
6
7
8
9
10
11
12
13
import java.util.Arrays;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;

public class FunctionExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        Function<Integer, Integer> square = n -> n * n;
        List<Integer> squares = numbers.stream().map(square).collect(Collectors.toList());
        System.out.println("Squares: " + squares);
    }
}

Consumer<T>

Consumer<T> 表示接受 T 类型的输入并执行操作而不返回结果的函数，非常适合打印或记录等副作用操作。源码如下：

1
2
3
4
5
6
7
8
9
10
@FunctionalInterface
public interface Consumer<T> {
  /**
   * Performs this operation on the given argument.
   * @param t the input argument
   */
    void accept(T t);
    
    // default methods
}

使用举例：

  • 记录用户操作
  • 打印数字列表
  • 更新对象属性

如下代码，Consumer<String> 被定义为 printName，它打印一个字符串。然后，我们使用 forEach 方法和 printName 消费者对列表中的每个字符串进行打印。

1
2
3
4
5
6
7
8
9
10
11
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class ConsumerExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Tom", "Bob", "Cherry");
        Consumer<String> printName = name -> System.out.println(name);
        names.forEach(printName);
    }
}

Supplier<T>

Supplier<T> 表示该函数提供 T 类型的值而不采用任何参数，对于延迟初始化和延迟计算很有用。源码如下：

1
2
3
4
5
6
7
8
9
10
@FunctionalInterface
public interface Supplier<T> {
  /**
   * Gets a result.
   * @return a result
   */
  T get();
  
  // default methods
}

使用举例：

  • 创建新的对象实例
  • 生成随机数
  • 提供默认值

如下代码，Supplier<Double> 被定义为 randomSupplier，它返回一个随机数，我们使用 get 方法来调用供应商并获取随机数。

1
2
3
4
5
6
7
8
9
10
11
import java.util.function.Supplier;
import java.util.Random;

public class SupplierExample {
    public static void main(String[] args) {
        Supplier<Double> randomSupplier = () -> new Random().nextDouble();

        System.out.println("Random number: " + randomSupplier.get());
        System.out.println("Random number: " + randomSupplier.get());
    }
}

BiFunction<T,T,T>

BinaryOperator<T, T, T>，表示该函数接受两个 T 类型的输入并返回相同类型的结果，可用于组合或减少操作。源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@FunctionalInterface
public interface BiFunction<T, U, R> {

    /**
     * Applies this function to the given arguments.
     *
     * @param t the first function argument
     * @param u the second function argument
     * @return the function result
     */
    R apply(T t, U u);
  // default methods
}
@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T> {
    
}

使用举例：

  • 求两个值的最大值
  • 将两个数字相加
  • 连接字符串

如下代码，BinaryOperator<Integer> 被定义为将两个整数相加。我们使用 apply() 方法来调用操作符并获取结果。源码如下：

1
2
3
4
5
6
7
8
9
10
import java.util.function.BinaryOperator;

public class BinaryOperatorExample {
    public static void main(String[] args) {
        BinaryOperator<Integer> add = (a, b) -> a + b;

        int result = add.apply(3, 5);
        System.out.println("Result: " + result); // 输出: Result: 8
    }
}

Java 8 中的这些内置函数接口为函数式编程奠定了基础，使我们能够使用 Lambda 表达式并简化代码。由于它们的多功能性，我们可以将它们用于广泛的应用，从数据转换到过滤等等。

Lambda 表达式

解释

Lambda 表达式是 Java 8 的一个关键特性，它允许我们以清晰简洁的方式创建紧凑的匿名函数，提供了一种以更简单的形式表示函数式接口的方法，因此，Lambda 表达式是 Java 函数式编程的基石。

Lambda 表达式的一般语法如下：

1
() -> {}

Lambda 包含三个部分：

  • () 代表入参，表示 Lambda 函数的输入参数，多个参数用逗号分隔，如果只有一个参数，括号可以省略；
  • -> 代表箭头运算符，它将参数与 Lambda 表达式的主体分开；
  • {} 代表主体，它包含函数逻辑，如果只有一条语句，大括号可以省略；

主体只有一条语句的 Lambda 表达式示例：

1
Function<String, String> toUpper = s -> s == null ? null : s.toUpperCase();

上述示例中，因为只有一个参数，所以 () 被省略了，因为主体只有一语句，所以 {} 被省略了。

主体包含多条语句的 Lambda 表达式示例：

1
2
3
4
5
6
7
8
IntToLongFunction factorial =
    n -> {
      int result = 0L;
      for (int i = 0; i <= n; i++) {
        result += i;
      }
      return result;
    };

上述示例中，因为只有一个参数，所以 () 被省略了，因为主体包含多条语句，所以 {} 不能被省略。

上述两个示例，使用 Lambda 表达式来创建匿名函数，这使得我们能够编写内联逻辑，而无需额外的类定义。我们可以在需要我们传递函数接口的地方使用这种匿名函数。

工作原理

本文，我们将通过 Lambda 表达式的 Java 代码和 JVM 字节码的对比来探究 Lambda的内部工作原理。

在 Java 中，我们有两种类型的值：原生类型和对象引用，而 Lambda 显然不是原生类型，它实际上是一种返回对象引用的特殊表达式，有人把它叫传函数。

接下来，我们用 LambdaTest 测试类来对 num 进行加倍操作，并查看其字节码作为演示，示例代码如下：

1
2
3
public class LambdaTest {
    LongFunction<Long> doubleNum = num -> 2 * num;
}

使用 javap -c -p 指令编译其字节码，指令如下：

1
javap -c -p LambdaTest.class

指令执行结果如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Compiled from "LambdaTest.java"
public class com.yuanjava.LambdaTest {
    java.util.function.LongFunction<java.lang.Long> doubleNum;

  public com.yuanjava.LambdaTest();
    Code:
    0: aload_0
    1: invokespecial #1                  // Method java/lang/Object."<init>":()V
    4: aload_0
    5: invokedynamic #2,  0              // InvokeDynamic #0:apply:()Ljava/util/function/LongFunction;
    10: putfield      #3                  // Field doubleNum:Ljava/util/function/LongFunction;
    13: return

    private static java.lang.Long lambda$new$0(long);
    Code:
    0: ldc2_w        #4                  // long 2l
    3: lload_0
    4: lmul
    5: invokestatic  #6                  // Method java/lang/Long.valueOf:(J)Ljava/lang/Long;
    8: areturn
}

从上面的字节码可以看出它是以invokedynamic 调用开头，整个过程分析如下：

  • 编译：Java 编译器并没有为 Lambda 生成新的匿名内部类，而是使用了 Java 7 中引入的 invokedynamic 技术；
  • InvokeDynamic：invokedynamic 指令支持 JVM 上的动态语言，它可以将 JVM 对 Lambda 实例的创建推迟到运行阶段，与传统的匿名内部类相比，这提供了更大的灵活性和效率。
  • Lambda Metafactory：当 JVM 在运行时遇到 invokedynamic 指令，它会调用一个名为 LambdaMetafactory.metafactory() 的特殊方法，此方法负责创建 Lambda 表达式的实际实现。JVM 会使用此元工厂方法生成表示 Lambda 的轻量级类或方法句柄。
  • 创建实例：LambdaMetafactory 会动态创建 Lambda 表达式的实例：
    • 如果 Lambda 是无状态的（它不会从封闭作用域捕获任何变量），则此实例通常是单例。
    • 如果 Lambda 捕获变量，它将使用这些捕获的值创建一个新实例。
  • 运行：运行 Lambda 表达式，就如同实现函数接口的匿名内部类的实例一样，JVM 会确保 Lambda 符合预期函数接口的单一抽象方法。

Lambda和函数式接口的关系

上文，我们分析了函数式接口以及 Lambda，那么两者存在什么关系呢？

在编程语言中，lambda 表达式和函数式接口通常在一起使用，尤其在支持函数式编程的语言中（比如 Java 和 Python）。它们之间的关系可以通过以下几点来理解：

  • Lambda 表达式是一种语法通常较为简洁的匿名函数，即没有名称的函数，它可以用来简洁地表示一个函数或方法。

  • 函数式接口是一个只包含一个抽象方法的接口，这种接口可以有多个默认方法或静态方法，但只能有一个抽象方法。

  • 函数式接口的主要目的是用作 Lambda 表达式的目标类型。

  • 在 Java 中，Lambda 表达式可以被赋值给一个函数式接口的引用

  • Lambda 表达式通过实现函数式接口的抽象方法，将行为作为参数传递，从而实现了函数式编程的理念

总结来说，Lambda 表达式提供了一种简洁的方法来定义匿名函数，而函数式接口提供了一种目标类型，使得这些匿名函数可以被类型安全地传递和使用，两者的结合在现代编程中极大地促进了函数式编程的应用。

总结

在本文中，我们学习了什么是函数式接口以及如何定义函数式接口，接着我们分析了 lambda 表达式及其内部工作原理。

函数式编程和 lambda 表达式可以为我们的代码带来新的优雅和效率，所以建议日常开发中可以多多实操，享受它给我们带来的便捷。

学习交流

如果你觉得文章有帮助，请帮忙转发给更多的好友，或关注公众号：猿java，持续输出硬核文章。

drawing