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

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

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

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

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

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

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

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

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

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

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

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

百度百科是这样说的：

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

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

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

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

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

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

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

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

咱们能够看看 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;
}

在 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 关键字及语句分号。
- 解决逻辑过于臃肿简单，还是应用具体子类改写较好，保障可读性。

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

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

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

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

前言

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

什么是 Lambda 表达式？

什么是函数式编程？

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

函数式接口

Comparator

常见的函数式接口

如何应用 Lambda 表达式？

根本语法

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

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

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

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

总结

最初的最初

Just My Socks（注册教程内含优惠码）

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

前言

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

什么是 Lambda 表达式？

什么是函数式编程？

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

函数式接口

Comparator

常见的函数式接口

如何应用 Lambda 表达式？

根本语法

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

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

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

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

总结

最初的最初

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）