java函数式编程api_Lambda表达式函数式编程StreamAPI学习笔记

心已赠人 2022-11-12 02:55 220阅读 0赞

【官方正版】java核心编程清华大学

71.2元

包邮

(需用券)

去购买 >

![a290a7376ba99aed9dccc24acbf4c395.png][]

什么是Lambda表达式

我们知道接口是无法直接被实例化的，你只能new他的实现类，但是假如当前接口只有一个抽象方法，又不想再创建一个类，在JDK8之前，你就只能使用匿名内部类。像下面这样:

new Thread(new Runnable() \{

@Override

public void run() \{

System.out.println("hello world");

\}).start();

现在的IDE已经很强大了，你只用写到new Runnable()就会帮你把代码补全，但是你还是要移动光标到run方法体内，写对应的代码。在学到匿名内部类的时候，我就希望代码变的简洁紧凑一些 (事实上官方写的指导书《The Java™ Tutorials》也是将Lambda式放在匿名类这一章下面的，介绍Lambda表达式这一章在: https://docs.oracle.com/javas... )。

JDK8之后上面的代码就可以化简成下面这样:

new Thread(()-> System.out.println("hello world")).start();

怎么样是不是变得相当简洁了呢! ()-> System.out.println("hello world") 就可以称之为Lambda表达式。Lambda是λ这个符号的名称。

维基百科是这样描述Lambda表达式的:

a function (or a subroutine) defined, and possibly called, without being bound to an identifier。

直接翻译的话就是: 可能被调用的一个函数或者是子程序，但是没有绑定到一个标识符上。

我们放到java里来理解一下，众所周知java是面向对象的，函数也是放在一个类中的。调用方法的话就大致有以下两种形式:

类名.方法名

类的实例.方法名。

所以在java中，我们姑且就可以将类名+方法名称之为一个标识符，因为我们通过类名(严谨的说是全类名)+方法名定位到一个方法。()-> System.out.println("hello world")，就是一个匿名类和匿名方法的组合化简之后产物，类名没有直接给出，方法名也是没有，这些通通是编译器来给。

百度百科是这样描述Lambda表达式的:

Lambda 表达式(lambda expression)是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象(lambda abstraction)，是一个匿名函数，即没有函数名的函数。--《百度百科》

我们知道数学中的演算是需要运算符(演算符的)，调用一个函数是需要给定参数的，是需要方法体的。

() 里面就可以放参数，-> 是运算符，-> 之后就是方法体。形如()->\{\}的表达式,在java中我们就可以称之为Lambda表达式。

因为Runnable接口中的run方法没有参数，所以()里面啥也没写。

顺便提一下，Lambda表达式并不算是java率先提出。2007年11月19，.NET Framework 3.5就已经引入了，jdk8的发布时间是2014-03-18。主流的编程语言应该都有这个概念。

我们来想想为什么可以化简到这种地步，假如我们有这样两个方法:

add(int i)

add(Long i)

我们称之为方法重载，同一个方法名，参数类型不同。我们在调用的时候,编译器或者说是JVM，就能根据我们给定的参数来调用对应的方法。那么new Thread(()-> System.out.println("hello world"))来推断这是Thread的哪一个构造函数也是能够做到的事情。所以看似你写的是这个：

new Thread(()-> System.out.println("hello world")).start();

事实上编译器会帮你补成:

new Thread(new Runnable() \{

@Override

public void run() \{

System.out.println("hello world");

\}).start();

这也是一些人说在某些情况下Lambda性能不佳的原因。

适用场景

如果你打开Runnable接口看的话，会发现Runnable接口上有一个注解: @FunctionalInterface。FunctionalInterface意味函数式接口，什么是函数式接口呢？ 就是一个接口中只有一个抽象方法的接口，我们称之为函数式接口。我们知道，jdk8之前接口中只能放抽象方法，jdk8之后可以放非抽象方法。方法中要加上default关键字，我们称之为默认实现。形式如下:

@FunctionalInterface

public interface MyLambdaInterface \{

void sayHello(String str);

default void sayWorld(String str)\{

System.out.println(str);

加上@FunctionalInterface的接口,只能有一个抽象方法，允许存在和Object中方法名相同的方法，但要求参数类型一致。否则会通不过编译。如下所示:

@FunctionalInterface

public interface MyLambdaInterface \{

void sayHello(String str);

int hashCode();

boolean equals(Object obj);

default void sayWorld(String str)\{

System.out.println(str);

Lambda表达式的适用场景即为: 假如我有一个函数式接口，但是呢，我又不想创建这个类的显示实现类(显示实现类即为新建Class文件)，我又想使用这个方法，Lambda表达式大显身手的就到了。

如何使用以及 Lambda表达式的几种形式

我们首先介绍Lambda表达式的形式，在根据形式去讲解如何使用。

方法参数

Lambda从形式上来看更像是一个函数,(函数所需要的参数)->\{方法实现\}

方法参数的话 new Thread(()-> System.out.println("hello world")).start(); 这个就是一个例子。虽然原则上讲并不应该直接创建一个线程，应该通过线程池。

我们知道函数的参数类型可以是基本类型和引用类型，new Thread(()-> System.out.println("hello world")) 这个例子好像就是将一个方法作为参数传递进去了一样。

方法引用的形式一: 指向自己创建的方法

以MyLambdaInterface为例，方法引用我们可以这么写:

MyLambdaInterface myLambdaInterface = (str)-> System.out.println(str);

从形式上来讲，myLambdaInterface好像指向一个函数一样。

(str)-> System.out.println(str);就是方法sayHello的实现。

方法引用的形式二: 指向已存在的方法

指向已存在的方法的语法为:

Reference to a static method(引用一个静态方法):

public class Person \{

LocalDate birthday;

public static int compareByAge(Person a, Person b) \{

return a.birthday.compareTo(b.birthday);

方法引用的写法: Person::compareByAge

但是这句话直接出现在代码中会报错，我们需要找一个函数式接口来指向它。函数式接口中的方法返回类型和接收参数要和compareByAge保持一致，像下面这样。

public interface CompareTo \{

int compare(T t1,T t2);

CompareTo p = Person::compareByAge;

Reference to an instance method of an arbitrary object of a particular type(对特定类型的实例方法的调用)

String\[\] stringArray = \{"Barbara", "James", "Mary", "John",

"Patricia", "Robert", "Michael", "Linda"\};

Arrays.sort(stringArray, String::compareToIgnoreCase);

Reference to an instance method of a particular object (对特定对象的实例方法的调用)

首先你需要new一个对象, 形式就是 函数式接口 = 对象::方法

或者将 对象::方法当做一个方法参数传递进去。

Reference to a constructor (引用构造函数)

形式: 类名:: new。用法和前面三种是一致的，可以当做一个函数式接口的实现，也可以当做一个方法参数。

Lambda表达式本质上也是内部类，那么同内部类一样，要想要访问局部变量，那么这个局部变量一定要是final类型的。

现在我们来总结一下Lambda表达式的写法:

形式大致是这样: (函数式接口所需的参数)->方法体;

假如方法体只有一行，可以不用写\{

例如:

new Thread(()-> System.out.println()).start();

假如有多行的话需要写\{

我们可以认为每一个Lambda表达式都是一个函数式接口的匿名实现。

JDK提供的函数式接口

JDK也内置了一些函数式接口，这些函数式接口大多都在java.util.function下,理解这些函数式接口是学习Stream API的关键。这里我们选取几个比较经典的讲解一下。

Predicate 断言中抽象方法为: boolean test(T t);

Consumer 消费，抽象方法为: void accept(T t);

Function 函数式，抽象方法为: R apply(T t);‘

Supplier 供给型，抽象方法为: T get();

boolean test(T t); 这个方法接收一个参数，返回一个boolean类型的值。

我们可以这样写:

Predicate predicate = (str)-> str.contains("s");

还可以这样写:

List list = new ArrayList<>();

Predicate predicate = list::add;

predicate.test("add");//等价于调用list.add("add")

predicate.test("bb");

Consumer、 Function、 Supplier用法类似，这里不再做过多的介绍。

由函数式编程到 Stream API

首先Stream是一个接口,位于java.util.stream下。 假如我们的集合泛型是一个学生类，像下面这样。

List student = new ArrayList<>();

那么假如我像统计年龄在18岁以上的学生总数，那么在不用流的情况下，我们通常是这样做的。

int count = 0;

List studentList = new ArrayList<>();

for (Student student : studentList) \{

if (student.getAge() > 18)\{

count++;

Student可以映射进数据库中,我们在数据库做这样的事情是简单的，那么在代码能否像sql一样执行count,where操作呢。

有了流之后就可以，我们可以这样写:

studentStream.filter( (student) -> student.getAge() > 18).count();

是不是变的简单多了呢! 那我能不能group by 在count呢，也是可以的。按性别分组求出男生和女生的人数。

Map result = studentStream.collect(Collectors.groupingBy(Student::isSex, counting()));

细究他的实现的话，这个并不是本篇的主题，本篇只是简单入门，详细讨论是另一篇了。

顺便提一下， 流有两种类型，串行和并行流，这将是我们下一篇文章重点阐释的内容。

总结一下

Lambda表达式使得代码更为紧凑，使得可以将方法作为参数进行传递。

由Lambda方法进一步到Stream，我们就可以将一些数据库的操作,比如where，group by，移植进入代码中，而且更为简洁。

参考资料: The Java™ Tutorials

java 11官方入门(第8版)教材

79.84元

包邮

(需用券)

去购买 >

![f0f3f55624fb396b1764d42d6df88864.png][]

[a290a7376ba99aed9dccc24acbf4c395.png]: /images/20221022/a8c6e415e7604d38a5c0d3997a087452.png
[f0f3f55624fb396b1764d42d6df88864.png]: /images/20221022/a7f2e2c85a8c4df1a2fbc007af33b92d.png