关于后端:回炉重造Lambda-表达式

前言

Lambda 表达式（Lambda Expression），置信大家对 Lambda 必定是很相熟的，毕竟咱们数学上常常用到它，即 λ。不过，感觉数学中的 Lambda 和编程语言中的 Lambda 表达式没啥关系，要说有关系就是都有 Lambda 这个词，噢！当然还有一个关系就是 Lambda 演算。

λ 演算（英语：lambda calculus，λ-calculus）是一套从数学逻辑中倒退，以变量绑定和替换的规定，来钻研函数如何抽象化定义、函数如何被利用以及递归的形式系统。它由数学家阿隆佐·邱奇在 20 世纪 30 年代首次发表。lambda 演算作为一种宽泛用处的计算模型，能够清晰地定义什么是一个可计算函数，而任何可计算函数都能以这种模式表白和求值，它能模仿繁多磁带图灵机的计算过程。

回到编程语言这方面，其实不只是 Java 引入了这个 Lambda 表达式，其余编程语言也有，比方 C++、Javascript、Python 等等。当然，本篇文章回顾的是 Java 中的 Lambda 表达式。

作为一个初学者，上面对于 Lambda 的了解必定不够谨严，甚至可能蕴含谬误，望观众老爷们能在评论区指出！

为什么要学这个 Lambda 表达式？

1. Java 8 的新个性，简化代码的编写。
2. 工作中会用到，避免看不懂他人写的代码。
3. 大家都学我也学。

什么是 Lambda 表达式？

Lambda 表达式是一个 匿名函数，换句话说，你有匿名函数，那么它这个函数就是所谓的 Lambda 表达式。

所谓匿名函数，顾名思义，就是没有函数名的函数。

那么必定有小伙伴会说，没有函数名，那我怎么调用这个函数啊？

是的，这个问题问得很好，先放弃这个疑难！在答复这个问题之前，我先来说说另一个概念——「函数式编程」。

什么是函数式编程？

函数式编程是一种编程范式，除此之外，还有申明式编程、命令式编程，也都是编程范式。

好吧，这里又扯出一个新的专业名词——「编程范式（Programming Paradigm）」。范式？置信正在浏览的你，在学习数据库常识的时候，必定学过第一范式、第二范式、第三范式，那当初又有一个编程范式，这是什么鬼？

百度百科是这样说的：

编程范型 、 编程范式 或程序设计法 （英语：Programming paradigm），（ 范即典范、榜样之意，范式即模式、办法），是一类典型的编程格调，是指从事软件工程的一类典型的格调（能够对照方法学）。如：函数式编程、程序编程、面向对象编程、指令式编程等等为不同的编程范型。

是不是太官网了，没关系，简略了解，我认为晓得函数式编程是一种写代码时的格调就 OK 了。

咱们须要 留神 的是，函数式编程中的「函数」二字，是数学上的函数，并不是咱们当初习惯了解的函数，也就是说，这是纯纯数学概念上的函数，即自变量的映射，比方 $y = f(x)$，自变量 $x$，通过函数 $f$ 映射成 $y$。

函数式编程和 Lambda 表达式有什么关系？

能够说，函数式编程容许应用一种表达式来示意一个函数，这种表达式就是 Lambda 表达式。

在 Java 中，函数式编程是通过一个接口标准来实现的，接口具备这种特点：

• 该接口有且只有一个形象办法
• 该接口应用 @FunctionalInterface 注解进行标识

具备这个特点的接口称为「函数式接口」。

当初，回到最开始说的，「没有函数名，那我怎么调用这个函数啊？」，这就是函数式接口的用处了，接口中只有一个形象办法，不必指定办法名称，就可能用 Lambda 表达式来调用这个函数（办法）了，不须要晓得函数名就可能实现调用。好比想在某个房间（接口）找集体（办法）来做事，我这个房间只有一个人，那么除了这个人，没有其他人能够来做事了，就不须要指定那谁谁谁过去帮忙，而是间接喊：就决定是你了！（这个比喻可能也不是很失当，当大略意思是这样哈哈哈）

函数式接口

Comparator

咱们能够看看 Comparator 接口，它有 @FunctionalInterface 注解，那么能够必定它是一个函数式接口。

@FunctionalInterface
public interface Comparator<T> {int compare(T o1, T o2);
    
    boolean equals(Object obj);
    
    default Comparator<T> reversed() {return Collections.reverseOrder(this);
    }
    
    default Comparator<T> thenComparing(Comparator<? super T> other) {Objects.requireNonNull(other);
        return (Comparator<T> & Serializable) (c1, c2) -> {int res = compare(c1, c2);
            return (res != 0) ? res : other.compare(c1, c2);
        };
    }
    ...
}

有小伙伴应该要说了，这个接口这么多办法，为什么还能是函数式接口？

留神了啊，咱们能够看到一个如同是形象的 equals 办法，然而，因为 equals 是 Object 中的办法，这种对 Object 类的办法的从新申明是会让办法变成一个具体的办法。所以，不要误会了，这里的形象办法就只有 compare 办法。

那可能有小伙伴要说了，接口中还能有具体的办法？

是的，没错，在 Java 8 中，接口中能够写具体的办法了。比方下面的 reversed 和 thenComparing 办法，都是具体的办法。

常见的函数式接口

• java.lang.Runnable

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

• java.util.concurrent.Callable

@FunctionalInterface
public interface Callable<V> {V call() throws Exception;
}

• java.lang.reflect.InvocationHandler

@FunctionalInterface
public interface InvocationHandler {public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

如何应用 Lambda 表达式？

在 Java 8 之前，咱们应用 Collections 的须要比拟器的 sort 办法，是这样的。

等等，忘了有比拟器参数的 sort 办法了？没关系，代码给你贴上：

public static <T> void sort(List<T> list, Comparator<? super T> c) {list.sort(c);
}

最开始的写法是这样的，因为 Comparator 是一个接口，不能间接实例化，所以须要一个类来实现这个接口作为真正的比拟器类，而后将这个 Comparator 实例对象作为 sort 办法第二个参数传入，实现排序，如下：

public class KeyComparator implements Comparator<Integer> {
    @Override
    public int compare(Integer v1, Integer v2) {return v1 - v2;}
}

List<Integer> keys = Arrays.asList(9, 3, 5, 10, 2);
Collections.sort(keys, new KeyComparator());
System.out.println(keys);    // [2, 3, 5, 9, 10]

起初，这种写法比拟麻烦，于是用匿名外部类改写这种写法，咱们不须要本人去编写一个类来实现这个接口了，间接用匿名外部类。就是这种写法：

List<Integer> keys = Arrays.asList(9, 3, 5, 10, 2);
Collections.sort(keys, new Comparator<Integer>() {
    @Override
    public int compare(Integer v1, Integer v2) {return v1 - v2;}
});
System.out.println(keys);    // [2, 3, 5, 9, 10]

当初，匿名外部类比起 Lambda 表达式，也是麻烦，咱们用 Lambda 进行改写：

List<Integer> keys = Arrays.asList(9, 3, 5, 10, 2);
Collections.sort(keys, (Integer v1, Integer v2) -> {return v1 - v2;});
System.out.println(keys);    // [2, 3, 5, 9, 10]

是吧，(Integer v1, Integer v2) -> {return v1 - v2;} 的写法，没有函数名，也能进行调用。

实际上，这样还不是最简的，最简的是这样：(v1, v2) -> v1 - v2

是不是很好奇啥时候能这样写？当初就通知你！

根本语法

(参数类型 参数名) -> {办法体}

基本上，这样写，是不会有问题的。上面说说何时能写得更加简略。

为了便于浏览，上面的「办法」指的是函数式接口中的形象办法

• 办法没有参数，那么能够间接写小括号，而后箭头，再写中括号，最初写办法体，即 () -> { 办法体}
• 办法有多个参数，那么多个参数就用逗号离开，同时参数类型是能够省略的，即 (v1, v2, ...) -> {办法体}
• 办法只有一个参数，那么小括号能够去掉，间接写参数名，而后箭头，再中括号和办法体，即 v -> {办法体}
• 办法体只有一条语句，无论是否有返回值，都能够省略大括号、return 关键字及语句分号。

状况一：办法无参数、无返回值

常见的就是 Runnable 接口了。

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

• 未应用 Lambda（应用匿名外部类）：

new Thread(new Runnable() {
    @Override
    void run() {System.out.println("线程开始跑了");
    }
}).start();

• 应用 Lambda：

// 写法一
new Thread(() -> {System.out.println("线程开始跑了")
}).start();
// 写法二，一条语句，那么省略大括号、return 关键字及语句分号
new Thread(() -> System.out.println("线程开始跑了")).start();

状况二：办法无参数，有返回值

例子：Callable 接口

@FunctionalInterface
public interface Callable<V> {V call() throws Exception;
}

• 未应用 Lambda（应用匿名外部类）：

FutureTask<String> stringFutureTask = new FutureTask<>(new Callable<String>() {
    @Override
    public String call() throws Exception {return "这里是返回值";}
});
stringFutureTask.run();
System.out.println(stringFutureTask.get());

• 应用 Lambda：

// 一条语句，省略大括号、return 关键字及语句分号
FutureTask<String> stringFutureTask = new FutureTask<>(() -> "这里是返回值");
stringFutureTask.run();
System.out.println(stringFutureTask.get());

状况三：办法一个参数、有返回值

我轻易找了 JDK 中的一个接口，如下：

@FunctionalInterface
interface Recognizer {boolean recognize(int c);
}

• 未应用 Lambda（应用匿名外部类）：

private final Recognizer A = new Recognizer() {
    @Override
    public boolean recognize(int c) {return c == 'a' || c == 'A';}
}

• 应用 Lambda：

private final Recognizer A = (c) -> c == 'a' || c == 'A';

// 一个参数，可省略小括号
private final Recognizer A = c -> c == 'a' || c == 'A';

状况四：办法多个参数、有返回值

间接举 Comparator 这个例子。

• 未应用 Lambda（应用匿名外部类）：

List<Integer> keys = Arrays.asList(9, 3, 5, 10, 2);
keys.sort(new Comparator()<Integer> {
    @Override
    public int compare(Integer v1, Integer v2) {return v1 - v2;}
});

• 应用 Lambda：

List<Integer> keys = Arrays.asList(9, 3, 5, 10, 2);
// 多个参数以逗号离开，可省略类型，一条语句，省略大括号、return 关键字及语句分号
keys.sort((v1, v2) -> v1 - v2);
System.out.println(keys);

总结

到这里，置信大家对于 Lambda 表达式有了一个根本的意识。总的来说：

• 必须是函数式接口能力应用 Lambda 表达式

语法：(参数类型 参数名称) ‐> {办法体}

• 若办法的参数列表：

  • 没有参数，则可间接用 ()；
  • 有一个参数，能够省略 ()，间接写参数；
  • 有多个参数，则 () 不可省略
  • () 内的参数类型能够省略

• 若办法体：

  • 只有一条语句，无论是否有返回值，都能够省略大括号、return 关键字及语句分号。
  • 解决逻辑过于臃肿简单，还是应用具体子类改写较好，保障可读性。

最初的最初

由自己程度所限，不免有谬误以及不足之处，屏幕前的靓仔靓女们 如有发现，恳请指出！

最初，谢谢你看到这里，谢谢你认真对待我的致力，心愿这篇博客对你有所帮忙！

你轻轻地点了个赞，那将在我的心里世界削减一颗亮堂而夺目的星！