• Java 中的 Lambda 表达式用法
  • 发布于 2个月前
  • 319 热度
    0 评论
前言
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 中,函数式编程是通过一个接口规范来实现的,接口具有这种特点:
1.该接口有且只有一个抽象方法
2.该接口使用 @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 关键字及语句分号。
  理逻辑过于臃肿复杂,还是使用具体子类改写较好,保证可读性。
用户评论