Java | Lambda表达式

Lamba的有效写法

接收一个 String型 参数，并返回一个 int，隐式的返回一个 int

(String s) -> s.length();

接收一个 Apple 类型参数，返回一个 boolean 型

(Apple a) -> a.getWeight() > 150

多个参数，没有返回值，可以包含多条语句

(int x, int y) -> {
    System.out.println("Result: ");
    System.out.println(x + y);
}

没有参数返回 int

() -> 42

语句需要花括号括起来，表达式可以省略花括号。

---

我们可以在函数式接口上使用Lambda表达式，所谓函数式接口，就是只定义了一个抽象方法的接口（Object 的public方法除外）。比如 Runnable 接口

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

@FunctionalInterface 注解表示你接下来要声明接口是函数接口，如果你用了该注解，而接口却不符合函数式接口的规范，那么编译器将会返回一个错误。

Lambda实践环绕执行 与 行为参数化实现步骤

下面是从一个文件中读取一行所需要的模板代码（使用了带资源的try语句，会自动关闭资源）

    public static String processFile(BufferedReaderProcessor p) throws IOException {
        try (BufferedReader br = new BufferedReader(new FileReader("C:\\data.txt"))) {
            return p.process(br);
        }
    }

上面就是环绕执行的例子，处理一个资源，常见的模式就是，打开一个资源，做一些处理，然后关闭资源。这个打开很清理阶段总是很类是，并且围绕着 执行处理的中要代码，这就是环绕执行。

环绕执行

我们可以通过将 处理代码参数化，来简化代码。

用 Lambda 来实现实现行为参数化，大致分四个步骤

第一步

首先创建函数式接口，用以传递行为

@FunctionalInterface
public interface BufferedReaderProcessor {
    
    String process(BufferedReader b) throws IOException;
}

第二步

将函数式接口作为框架方法的参数

    public static String processFile(BufferedReaderProcessor p) throws IOException {
        try (BufferedReader br = new BufferedReader(new FileReader("C:\\Users\\wqj24\\Desktop\\bbs.sql"))) {
            return p.process(br);  // 通过函数式接口传递的行为
        }
    }

第三步

通过传递不同的 Lambda 表达式，重用processFile方法，用不同的方式处理文件

String oneLine = processFile(br -> br.readLine());  // 读取一行
String twoLine = processFile(br -> br.readLine() + br.readLine());  // 读取两行
// ...

Java 8 中核心函数式接口

Predicate

断言型，接收一个泛型 T 对象，并返回一个 boolean，你可以在需要表示涉及类型 T 的布尔表达式时，使用该接口作为参数，然后传递行为代码。

@FunctionalInterface
public interface Predicate<T> {

    boolean test(T t);
}

Consumer

消费型，接收泛型 T 对象，没有返回值（void)，如果你需要访问对象T对象，并对其执行某些操作，就可以使用这个接口

@FunctionalInterface
public interface Consumer<T> {

    void accept(T t);
}

Function

函数型，java.util.function.Function<T, R> 接口定义了一个 apply 的方法，它接收一个 T 对象，返回一个 泛型R对象，如果你需要将输入对象映射到输出，可以使用这个接口

@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);
}

Supplier

供给型，定义了一个 get 方法，无参数，返回一个泛型 T 对象，如果你需要获取对象，可以使用这个接口。

@FunctionalInterface
public interface Supplier<T> {

    T get();
}