Java新特性
Java8新特性

函数式接口

# 函数式接口

1. 函数式接口概述
2. 什么是“实例化函数式接口”
- 2.1 传统方式的接口实例化
- 2.2 使用 Lambda 表达式实例化函数式接口
3. Java 内置的函数式接口
- 3.1 四大核心函数式接口
- 3.2 其他常用的函数式接口
4. 函数式接口的使用总结
5. 前端箭头函数与后端 Lambda 表达式的对比

# 1. 函数式接口概述

函数式接口 是只包含一个抽象方法的接口。这类接口可以使用 Lambda 表达式、方法引用或构造器引用进行实例化。函数式接口的本质是为 Lambda 表达式提供类型支持。
函数式接口可以使用 @FunctionalInterface 注解标注，这样做可以确保接口中只有一个抽象方法。若接口中有多个抽象方法，则编译器会报错。
Lambda 表达式的核心是实现函数式接口，允许将代码作为数据传递和操作。
Java 8 在 java.util.function 包中提供了一组常用的函数式接口，极大地简化了日常开发中的代码编写。

自定义函数式接口示例：

@FunctionalInterface
public interface MyInterface {
    void method1();
}

1
2
3
4

# 2. 什么是“实例化函数式接口”

实例化函数式接口指的是为函数式接口提供一个具体的实现，并创建一个该接口的对象。 在传统的面向对象编程中，我们通常使用实现类或匿名内部类来实现接口，然后实例化这个实现类。而在使用 Lambda 表达式时，我们不需要显式地编写实现类或匿名内部类，而是直接通过 Lambda 表达式为函数式接口提供实现。

如何去调用函数式接口里面的方法

当我们实现了具体的函数式接口以后，可以通过该接口的对象去调用实现之后的方法。

# 2.1 传统方式的接口实例化

在没有 Lambda 表达式之前，我们是通过实现类或匿名内部类来实现并实例化接口的。例如：

// 定义一个简单的函数式接口
@FunctionalInterface
public interface MyInterface {
    void method1();
}

// 使用匿名内部类实现接口并进行实例化
MyInterface instance = new MyInterface() {
    @Override
    public void method1() {
        System.out.println("传统方式的接口实例化");
    }
};
instance.method1(); // 输出: 传统方式的接口实例化

1
2
3
4
5
6
7
8
9
10
11
12
13
14

在这个示例中，匿名内部类的方式为接口 MyInterface 提供了具体的实现，并通过 new 创建了一个实例。这就是实例化的过程。

# 2.2 使用 Lambda 表达式实例化函数式接口

Lambda 表达式允许我们用更简洁的方式为函数式接口提供实现，并且直接实例化接口。例如：

// 定义一个简单的函数式接口
@FunctionalInterface
public interface MyInterface {
    void method1();
}

// 使用 Lambda 表达式实例化函数式接口
MyInterface instance = () -> System.out.println("Lambda 表达式的接口实例化");
instance.method1(); // 输出: Lambda 表达式的接口实例化

1
2
3
4
5
6
7
8
9

在这个示例中，() -> System.out.println("Lambda 表达式的接口实例化") 是 Lambda 表达式，它直接提供了接口中 method1() 方法的实现，并将其赋值给 MyInterface 类型的变量 instance，这就是函数式接口的实例化过程。

笔记

Lambda 表达式必须有一个接口对象来接收，这是因为 Lambda 表达式本质上是对函数式接口的实现。
使用 Lambda 表达式可以简化实例化过程，不需要显式编写实现类或匿名内部类。

# 3. Java 内置的函数式接口

Java 8 中定义了许多通用的函数式接口，最常用的有四大核心接口：Consumer、Supplier、Function、Predicate。

# 3.1 四大核心函数式接口

四大核心函数式接口

# 1. 消费型接口 `Consumer<T>`：

作用： 接收一个参数但不返回结果，主要用于对数据进行消费操作（如输出、存储）。
方法： void accept(T t)，其中参数 t 是要处理的输入数据。

使用场景： 常用于日志记录、打印操作等，只需要处理数据但不需要返回值的场景。

完整代码示例：

import java.util.function.Consumer;

public class ConsumerExample {
    public static void main(String[] args) {
        // 传统方式：使用匿名内部类
        Consumer<String> consumer1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("学习：" + s);
            }
        };
        consumer1.accept("Java");

        // Lambda 表达式方式
        Consumer<String> consumer2 = s -> System.out.println("学习：" + s);
        consumer2.accept("HTML");

        // 更复杂的操作，如日志记录
        Consumer<String> logger = message -> System.out.println("日志记录：" + message);
        logger.accept("操作成功");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 2. 供给型接口 `Supplier<T>`：

作用： 无参数但有返回值，主要用于提供数据（如生成对象、获取数据）。
方法： T get()，其中返回值 T 是生成的数据类型。

使用场景： 常用于懒加载、数据生成、资源获取等场景。

完整代码示例：

import java.util.function.Supplier;

public class SupplierExample {
    public static void main(String[] args) {
        // 传统方式：使用匿名内部类
        Supplier<String> supplier1 = new Supplier<String>() {
            @Override
            public String get() {
                return "我是传统方式生成的数据";
            }
        };
        System.out.println(supplier1.get());

        // Lambda 表达式方式
        Supplier<String> supplier2 = () -> "我是通过 Lambda 生成的数据";
        System.out.println(supplier2.get());

        // 更复杂的供给操作，如生成随机数
        Supplier<Double> randomSupplier = () -> Math.random();
        System.out.println("生成的随机数：" + randomSupplier.get());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 3. 函数型接口 `Function<T, R>`：

作用： 接收一个参数并返回结果，主要用于对数据进行转换操作。
方法： R apply(T t)，其中 t 是输入数据，R 是返回结果。

使用场景： 常用于数据转换、格式化处理、属性提取等场景。

完整代码示例：

import java.util.function.Function;

public class FunctionExample {
    public static void main(String[] args) {
        // 传统方式：使用匿名内部类
        Function<String, Integer> function1 = new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return s.length();
            }
        };
        System.out.println(function1.apply("Hello"));

        // Lambda 表达式方式
        Function<String, Integer> function2 = s -> s.length();
        System.out.println(function2.apply("Lambda"));

        // 使用方法引用简化操作
        Function<String, Integer> function3 = String::length;
        System.out.println(function3.apply("Method Reference"));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 4. 断言型接口 `Predicate<T>`：

作用： 接收一个参数并返回一个布尔值，主要用于条件判断。
方法： boolean test(T t)，其中 t 是输入数据，返回值是布尔类型的判断结果。

使用场景： 常用于过滤、验证数据等场景。

完整代码示例：

import java.util.function.Predicate;

public class PredicateExample {
    public static void main(String[] args) {
        // 传统方式：使用匿名内部类
        Predicate<String> predicate1 = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length() > 5;
            }
        };
        System.out.println(predicate1.test("Hello")); // false
        System.out.println(predicate1.test("Predicate")); // true

        // Lambda 表达式方式
        Predicate<String> predicate2 = s -> s.length() > 5;
        System.out.println(predicate2.test("Lambda")); // false
        System.out.println(predicate2.test("Function Interface")); // true

        // 结合流操作进行数据过滤
        List<String> names = Arrays.asList("Alice", "Bob", "Charlotte");
        List<String> longNames = names.stream()
                                      .filter(predicate2) // 过滤长度大于 5 的名字
                                      .collect(Collectors.toList());
        System.out.println("名字长度大于 5 的有：" + longNames);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 3.2 其他常用的函数式接口

Java 8 还提供了许多其他函数式接口，适用于不同的场景。以下是一些常用接口及其应用场景：

BiFunction<T, U, R>： 接收两个参数并返回一个结果，常用于双输入转换操作。
BiConsumer<T, U>： 接收两个参数但不返回结果，常用于双输入操作，如同时处理键值对。
UnaryOperator<T>： 接收一个参数并返回同类型结果，常用于对数据进行简单转换。
BinaryOperator<T>： 接收两个相同类型的参数并返回相同类型的结果，常用于求和、取最大值等操作。

# 4. 函数式接口的使用总结

何时使用 Lambda 表达式： Lambda 表达式主要用于简化对函数式接口的实现，在以下场景中，特别适合使用 Lambda 表达式：
- 回调函数或事件处理： 当需要传递一段逻辑或行为而不是具体的值时，Lambda 表达式可以简洁地实现接口方法，避免使用冗长的匿名内部类。例如在按钮点击事件、异步操作等场景中。
- 集合操作或流处理： 在进行集合过滤、排序、映射等操作时，Lambda 表达式与 Stream API 结合使用，可以极大地提高代码的可读性和简洁性。例如在 filter、map 等操作中。
- 只需实现一个方法的接口： 当你处理的接口只有一个抽象方法时（即函数式接口），如 Runnable、Comparator、Callable 等，Lambda 表达式是最简洁的实现方式。
如何选择合适的函数式接口： 在定义接口时，优先考虑使用 Java 提供的内置函数式接口，如 Consumer、Supplier、Function、Predicate 等。这些接口通常已经覆盖了大部分常见场景，可以避免自定义不必要的接口，从而提高代码复用性。
最佳实践： 在复杂场景中，结合流操作和函数式接口使用 Lambda 表达式，可以大幅简化代码逻辑。比如在数据处理、过滤、转换、聚合等操作中，Lambda 表达式能让代码更加简洁、直观，并且易于维护。

# 5. 前端箭头函数与后端 Lambda 表达式的对比

提示

如果你是一个全栈开发者，可以关注一下前端的箭头函数和后端的 Lambda 表达式之间的这些区别。我经常在评论区看到前端开发者对后端开发者不愿意使用 Lambda 表达式表示不理解，甚至有些嘲讽。但是如果你真正深入了解过这两者的本质区别，你就不会这么认为了。就像 Java 和 JavaScript 虽然名字相似，但实际上是完全不同的语言一样，前端的箭头函数和后端的 Lambda 表达式在设计初衷和使用场景上有很大不同。对于前端来说，箭头函数的写法确实更简洁，而在后端场景中，使用 Lambda 表达式有时候需要更多的考虑，具体情况并不能一概而论。

# 1. 语法上的相似性

虽然前端的箭头函数和后端的 Lambda 表达式在语法上有相似之处，它们都用于简化函数的定义，但在设计理念、使用场景、底层实现上却有显著的区别。

Java Lambda 表达式：

(int x, int y) -> x + y;

JavaScript 箭头函数：

(x, y) => x + y;

从语法上看，Java 的 Lambda 表达式和 JavaScript 的箭头函数都使用箭头符号 -> 或 => 来定义函数，实现简洁的表达方式。不过，它们背后的机制和设计理念有很大的不同。

# 2. Java Lambda 表达式的特点

函数式接口的实现： Java 的 Lambda 表达式是函数式接口的实现。本质上，它是用来简化实现只有一个抽象方法的接口的。
静态类型检查： Java 是静态强类型语言，Lambda 表达式中的参数类型通常由编译器进行类型推断或由开发者显式指定。
上下文依赖： Java 的 Lambda 表达式需要在明确的上下文中使用，通常被赋值给一个函数式接口类型的变量。
与方法引用结合： Java Lambda 表达式可以与方法引用结合使用，进一步简化代码。

示例：

@FunctionalInterface
interface MyInterface {
    void method1();
}

// 使用 Lambda 表达式实现接口的抽象方法
MyInterface instance = () -> System.out.println("Lambda 实现了接口的方法");
instance.method1(); // 输出: Lambda 实现了接口的方法

1
2
3
4
5
6
7
8

在这个例子中，Lambda 表达式通过实现函数式接口的唯一抽象方法来完成工作。Lambda 表达式需要一个接口对象接收，因为它本质上是接口方法的实现。

# 3. JavaScript 箭头函数的特点

函数表达式的简写： JavaScript 的箭头函数是一种匿名函数的简写，主要用于简化函数表达式的书写。
this 绑定机制： 箭头函数的 this 绑定是在定义时确定的，它绑定到箭头函数所在的上下文对象，而普通函数的 this 是动态绑定的。
隐式返回： 如果箭头函数体中只有一条语句，可以省略大括号 {} 和 return 关键字，直接返回结果。
没有 arguments 对象： 箭头函数没有自己的 arguments 对象，如果需要访问 arguments，只能从外层作用域中获取。

示例：

// 箭头函数的基本使用
const greet = () => console.log("Hello, World!");
greet(); // 输出: Hello, World!

// 箭头函数简化回调函数
setTimeout(() => console.log("这是一秒后的输出"), 1000);

1
2
3
4
5
6

JavaScript 的箭头函数不需要实现接口方法，也不需要接口对象接收。它只是用于简化函数定义，并解决传统函数中 this 绑定的问题。

# 4. 使用场景的不同

Java Lambda 表达式 主要用于简化函数式编程中的操作，如集合处理、流处理和回调函数。它需要与函数式接口配合使用，是 Java 8 引入的一个核心特性，旨在提高代码简洁性和可读性。
JavaScript 箭头函数 在前端开发中常用于简化回调函数、异步操作和闭包中的 this 处理。它的设计初衷更多是为了提升开发体验，减少样板代码。

# 5. 底层机制的区别

Java Lambda 表达式 的底层机制涉及类型推断、字节码生成和函数式接口。编译器在处理 Lambda 表达式时，会生成匿名类或通过动态方法 invokedynamic 生成实现。
JavaScript 箭头函数 是 ECMAScript 6 引入的特性，属于 JavaScript 引擎的实现。它在编译时会被转换为更高效的代码，且重点在于 this 绑定的简化。

# 6. 设计理念上的差异

Java Lambda 表达式 的设计理念来源于函数式编程，它旨在让 Java 更好地支持这一编程范式，同时简化函数式接口的实现。
JavaScript 箭头函数 的设计理念则是简化函数表达式的定义，并优化 this 的处理，使得回调和闭包的编写更加简洁和直观。

总结

前端的箭头函数 是一种语法简化工具，不需要依赖接口，主要用于提升代码简洁性，尤其是在回调和异步操作中表现出色。
后端的 Lambda 表达式 则严格依赖函数式接口，是为了支持函数式编程而设计的，主要用于简化单一抽象方法接口的实现。

编辑此页

上次更新: 2024/12/28, 18:32:08

← Lambda 表达式方法的引用→

函数式接口

# 函数式接口

# 1. 函数式接口概述

# 2. 什么是“实例化函数式接口”

# 2.1 传统方式的接口实例化

# 2.2 使用 Lambda 表达式实例化函数式接口

# 3. Java 内置的函数式接口

# 3.1 四大核心函数式接口

# 1. 消费型接口 Consumer<T>：

# 2. 供给型接口 Supplier<T>：

# 3. 函数型接口 Function<T, R>：

# 4. 断言型接口 Predicate<T>：

# 3.2 其他常用的函数式接口

# 4. 函数式接口的使用总结

# 5. 前端箭头函数与后端 Lambda 表达式的对比

# 1. 语法上的相似性

# 2. Java Lambda 表达式的特点

# 3. JavaScript 箭头函数的特点

# 4. 使用场景的不同

# 5. 底层机制的区别

# 6. 设计理念上的差异

# 1. 消费型接口 `Consumer<T>`：

# 2. 供给型接口 `Supplier<T>`：

# 3. 函数型接口 `Function<T, R>`：

# 4. 断言型接口 `Predicate<T>`：