函数式编程：Lambda 表达式
函数式编程：Lambda 表达式
每博一文案
曾经读过的依然令我感动的句子，生活总是不如意，但往往是在无数痛苦中，但往往是在无数痛苦中，在重重矛盾
和艰难中才能成熟起来，坚强起来，爱情啊，它使荒芜变成繁荣，平庸变得伟大，使死去的复活，活着的闪闪发光，
即使爱情是不尽的煎熬折磨，像冰霜般严厉，烈火般烤灼，但爱情对心和身体健男女是那样的自然，同时又永远让我们感到新奇神秘和不可思议....... 。生活中真正的勇士向来默默无闻，喧哗不止的永远是自视高贵的一群，无论精神是多么独立，感情却总是在寻找以一种依附，寻找一种归宿，亲人之间的感情是多么重要，假如没有这种感情，我们活在这个世界是多么悲哀啊，只有劳动才能使人在
生活中强大，不论什么人，最终还是要崇尚哪些用双手创造生活的财富者，人们宁愿关心一个蹩脚的电影演。
? —————— 《平凡的世界》路遥
@
目录
1. 函数式编程
我们先看看什么是函数。函数是一种最基本的任务，一个大型程序就是一个顶层函数调用若干底层函数，这些被调用的函数又可以调用其他函数，即大任务被一层层拆解并执行。所以函数就是面向过程的程序设计的基本单元。
Java不支持单独定义函数，但可以把静态方法视为独立的函数，把实例方法视为自带this参数的函数。
而函数式编程（请注意多了一个“式”字）——Functional Programming，虽然也可以归结到面向过程的程序设计，但其思想更接近数学计算。
我们首先要搞明白计算机（Computer）和计算（Compute）的概念。
在计算机的层次上，CPU执行的是加减乘除的指令代码，以及各种条件判断和跳转指令，所以，汇编语言是最贴近计算机的语言。
而计算则指数学意义上的计算，越是抽象的计算，离计算机硬件越远。
对应到编程语言，就是越低级的语言，越贴近计算机，抽象程度低，执行效率高，比如C语言；越高级的语言，越贴近计算，抽象程度高，执行效率低，比如Lisp语言。
函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函数是有副作用的。
函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！
函数式编程最早是数学家阿隆佐·邱奇研究的一套函数变换逻辑，又称Lambda Calculus（λ-Calculus），所以也经常把函数式编程称为Lambda计算。
Java平台从Java 8开始，支持函数式编程。
2. Lambda 表达式概述
相信大家一定在相关的框架的源码中看到不少 使用了 lambda 表达式的内容吧。如果我们想要阅读框架的源码上的逻辑，则必须了解，明白 Lambda 表达式的格式，语法了。
Java Lambda 表达式是 Java8 的新特性。Java lambda 表达式是 Java进入函数式编程的第一步。因此，Java lambda 表达式时可以单独创建的，而无需属于任何类。这一点很重要。Java Lambda 表达式可以像对象一样传递并按需执行。
Java lambda 表达式通常用于实现 简单的事件监听/回调，或在 Java Streams API 函数式编程时使用。
Lambda 是一个匿名函数 ，我们可以把 Lambda 表达式理解为是 一段可以传递的代码 （将代码像数据一样进行传递）。使用它可以写出更简洁，更灵活的代码。作为一种更紧凑的代码风格，使Java 语言表达能力得到了提升。
Lambda 表达式的本质：就是作为接口的实例。简单的说就是对 匿名实现接口的替换。 因为Java当中的接口是 不能 new 的，想要 new 的用该接口的话，就只能 new 该接口的实现类了。或者匿名实现接口。记住这个概念，只要你理解了这句话，那 Lambda 就十分简单了。
如下简单的举例：
如下是不使用 Lambda 表达式的方式，而是简单的匿名实现接口的方式。处理的
package blogs.blog13;
public class LambdaTest01 {
public static void main(String[] args) {
Runnable run = new Runnable() {
@Override
public void run() {
System.out.println("你好世界");
}
};
run.run();
}
}
同样的结果，使用 Lambda 表达式处理。
package blogs.blog13;
public class LambdaTest01 {
public static void main(String[] args) {
Runnable runnable = ()->System.out.println("你好世界");
runnable.run();
}
}
从上述两个使用同样的功能，但是 使用 Lambda 表达式解决的代码量更少一些。
3. Lambda 表达式的六种语法格式
Lambda 表达式：在 Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 -> 一杠 + 一个左箭头，该操作符被称为 Lambda 操作符 或 箭头操作符 。它将 Lamdba 分为两个部分。
箭头左侧 ： 指定了 Lambda 表达式需要的参数列表 。其实就是对应接口中的重写抽象方法中的参数列表。
箭头右侧 ：指定了 Lambda 体，即为 Lambda 表达式要执行的功能。其实就是对应接口中共重写抽象方法中的所要执行的语句/处理的逻辑。
一般的具体格式如下：
Runnable runnable = ()->System.out.println("你好世界");
()-> { lambda 体所要执行的语句}
我们知道 Lambda 表达式的本质就是：接口的实例化。匿名实现接口的替换 。既然要实现 接口 ，自然也就要重写其接口的抽象方法了。不同的接口中的抽象方法其结构也是不一样的。既然抽象方法都不一样了，那对应的接口中的 Lambda 表达式也有所不同了。
具体可以分为如下六种对应不同接口中的抽象方法中的不同的 Lambda 表达式的语法格式
这里我们会通过实现同样的功能，使用 匿名实现接口 与 Lambda 表达式 进行处理，两者之间进行一个对比，这样更容易理解 Lambda 表达式。
3.1 第一种：无参，无返回值，一条执行语句
情况1： 接口中的只有一个抽象方法，该抽象方法中：无参数，无返回值，只有一条语句 。
Lambda 表达式的语法格式如下：
() -> 要执行的语句 // 一条语句 {} 可以省略
补充： Runable 接口的源码：
匿名实现接口的方式：
package blogs.blog13;
public class LambdaTest01 {
public static void main(String[] args) {
Runnable run = new Runnable() {
@Override
public void run() {
System.out.println("你好世界");
}
};
run.run();
}
}
Lambda 表达式的方式：
package blogs.blog13;
public class LambdaTest01 {
public static void main(String[] args) {
Runnable runnable = ()->System.out.println("你好世界");
// () 参数列表：重写接口中抽象方法的
//System.out.println("你好世界"): 重写接口中抽象方法的中执行的语句
runnable.run();
}
}
3.2 第二种：有参数，无返回值，一条语句
情况2： 一个接口中只有一个抽象方法，该抽象方法：有参数，无返回值，只有一条语句。
Lambda 表达式的语法格式如下：
Consumer<String> consumer = (String s)-> System.out.println(s);
(参数的数据类型 参数名，参数的数据类型，参数名)-> 执行的语句;
补充： Consumer 接口的源码
匿名实现接口的方式：
import java.util.function.Consumer;
public class LambdaTest01 {
public static void main(String[] args) {
Consumer<String> consumer = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
consumer.accept("你好"); // 调用接口中重写的抽象方法
}
}
Lambda表达式的方式：
import java.util.function.Consumer;
public class LambdaTest01 {
public static void main(String[] args) {
Consumer<String> consumer = (String s)-> System.out.println(s);
consumer.accept("你好"); // 调用接口中重写的抽象方法
}
}
3.3 第三种：有参数，参数的数据类型可以省略，类型推断
情况3： 接口中的抽象方法有参数，但是该参数的数据类型可以省略不写（你也可以写上），Java自动会自动类型的推断，与 泛型 ，数组中的类型推断类似的。
Lambda 表达式的语法格式如下：
Consumer<String> consumer = (s)-> System.out.println(s); // 数据类型可以省略，该数据类型Java会自行推断出来。
(参数名)-> 执行的语句;
匿名实现接口的方式：
import java.util.function.Consumer;
public class LambdaTest01 {
public static void main(String[] args) {
Consumer<String> consumer = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
consumer.accept("你好"); // 调用接口中重写的抽象方法
}
}
Lambda表达式的方式：
import java.util.function.Consumer;
public class LambdaTest01 {
public static void main(String[] args) {
Consumer<String> consumer = (s)-> System.out.println(s);
consumer.accept("你好"); // 调用接口中重写的抽象方法
}
}
3.4 第四种：只有一个参数，无返回值，一条语句
情况4： 接口中的抽象方法：只有一个参数，无返回值，一条语句。
Lambda 表达式的语法格式如下：
Consumer<String> consumer = s-> System.out.println(s); //数据类型可以省略(Java自动推断出来)，一个参数 () 圆括号可以省略，一条语句{} 可以省略
参数-> 执行的语句
Lambda表达式的方式：
import java.util.function.Consumer;
public class LambdaTest01 {
public static void main(String[] args) {
Consumer<String> consumer = s-> System.out.println(s);
consumer.accept("你好"); // 调用接口中重写的抽象方法
}
}
3.5 第五种：有多个参数，多条语句，有返回值
情况5： 接口中的抽象方法：有多个参数，多条语句，有返回值。
Lambda 表达式的语法格式如下：
Comparator<Integer> comparator = (o1,o2)->{
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
};
/* (参数名，参数名) -> {
执行的多条语句;
执行的多条语句;
return 返回值;
} 参数类型可以省略Java自行推断出来，多条语句使用{} 花括号括起来， return 返回值。
*/
// 或者
Comparator<Integer> comparator1 = (o1,o2)->{
System.out.println(o1);
System.out.println(o2);
return Integer.compare(o1,o2);
};
补充： Comparator 部分源码
@FunctionalInterface
public interface Comparator<T> {
int compare(T o1, T o2);
}
匿名实现接口的方式：
import java.util.Comparator;
public class LambdaTest01 {
public static void main(String[] args) {
Comparator<Integer> comparator = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
//或者 return Integer.compare(o1,o2);
}
};
int compare = comparator.compare(21, 12);// 调用该接口中重写的抽象方法
System.out.println(compare);
}
}
Lambda表达式的方式：
import java.util.Comparator;
public class LambdaTest01 {
public static void main(String[] args) {
Comparator<Integer> comparator = (o1,o2)->{
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
};
int compare = comparator.compare(21, 12);// 调用该接口中重写的抽象方法
System.out.println(compare);
System.out.println("*****************************");
// 或者
Comparator<Integer> comparator1 = (o1,o2)->{
System.out.println(o1);
System.out.println(o2);
return Integer.compare(o1,o2);
};
int compare2 = comparator.compare(21, 12);// 调用该接口中重写的抽象方法
System.out.println(compare2);
}
}
3.6 第六种：有多个参数，有返回值，一条语句
情况6： 接口中抽象方法：有多个参数，有返回值，只有一条语句
Lambda 表达式的语法格式如下：
Comparator<Integer> comparator = (o1,o2)->Integer.compare(o1,o2);
// (参数名1，参数名2)-> return 返回的值
// 当接口中的抽象方法只有一个返回值时，其 {} 和 return 都可以省略，注意：要么两者都省略，要么都不省略，不然编译无法通过的。
匿名实现接口的方式：
import java.util.Comparator;
public class LambdaTest01 {
public static void main(String[] args) {
Comparator<Integer> comparator = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
//或者 return Integer.compare(o1,o2);
}
};
int compare = comparator.compare(21, 12);// 调用该接口中重写的抽象方法
System.out.println(compare);
}
}
Lambda表达式的方式：
import java.util.Comparator;
public class LambdaTest01 {
public static void main(String[] args) {
Comparator<Integer> comparator = (o1,o2)->Integer.compare(o1,o2);
int compare = comparator.compare(21, 12);// 调用该接口中重写的抽象方法
System.out.println(compare);
}
}
当接口中的抽象方法只有一个返回值时，其 {} 和 return 都可以省略，注意：要么两者都省略，要么都不省略，不然编译无法通过的。
3.7 Lambda 表达式六种语法格式总结：
- 在 Lambda 表达式中：接口中重写的抽象方法中的参数的数据类型可以省略，Java会自行推断出来的。
- 如果 Lambda 表达式中只有一个参数，其一对
{}花括号可以省略。 - 如果 Lambda 表达式中只有一条语句一个返回值，则：return 关键字和 {} 花括号都可以省略，注意： ：要么两者都省略，要么都不省略，不然编译无法通过的
- 如果接口中 的抽象方法有多条语句，则需要使用
{}花括号。括起来。 - Lambda 表达式的本质：就是函数式接口的实例。替换匿名实现类的方式
- 如果一个接口中，只声明了一个抽象方法，(被 static ,default 修饰的抽象方法不算)。则此接口就称为 “函数式接口”。
上述Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda 表达式中无需指定类型，程序依然可以编译，这是因为javac根据程序的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的 “类型推断”
3.8 补充：作为参数传递 Lambda 表达式
作为参数传递 Lambda 表达式：为了将 Lambda 表达式作为参数传递，接收Lambda 表达式的参数类型必须是与该 Lambda 表达式兼容的函数式接口的类型。
举例一：
匿名实现接口的方式：
package blogs.blog13;
import java.util.function.Consumer;
public class LambdaTest02 {
public static void happyTime(double money, Consumer<Double> consumer) {
consumer.accept(money);
}
// 匿名实现接口 传递接口实例
public static void main(String[] args) {
// 调用方法
happyTime(600,new Consumer<Double>() {
// 重写 Consumer 接口中的 accept()抽象方法
@Override
public void accept(Double aDouble) {
System.out.println("Hello World");
}
});
}
}
Lambda 表达式处理
import java.util.function.Consumer;
public class LambdaTest02 {
public static void happyTime(double money, Consumer<Double> consumer) {
consumer.accept(money);
}
// Lambda 表达式处理
public static void main(String[] args) {
// 调用方法
happyTime(600,(Double d)-> System.out.println("Hello World"));
// (Double d) 是 Consumer 接口中 accept()抽象方法的参数
// System.out.println("Hello World") 是 Consumer 接口中 accept()抽象方法执行的语句。
}
}
举例二：
匿名实现接口的方式：
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
public class LambdaTest02 {
/**
* 根据给定的规则，过滤集合中的字符串，此规则由 Predicate 的方法决定
*/
public static List<String> filterString(List<String> list, Predicate<String> pre) {
ArrayList<String> filterList = new ArrayList<>();
for(String s : list) {
if(pre.test(s)) {
filterList.add(s);
}
}
return filterList;
}
public static void main(String[] args) {
List<String> list = Arrays.asList("北京","天津","南京","东京","西京");
List<String> list2 = filterString(list, new Predicate<String>() {
// 重写 Predicate 接口中的 test(T t) 抽象方法
@Override
public boolean test(String s) {
return s.contains("京"); // 字符串中含有 京 字的返回 true,否则返回 false
}
});
System.out.println(list2);
}
]
Lambda 表达式处理
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
public class LambdaTest02 {
/**
* 根据给定的规则，过滤集合中的字符串，此规则由 Predicate 的方法决定
*/
public static List<String> filterString(List<String> list, Predicate<String> pre) {
ArrayList<String> filterList = new ArrayList<>();
for(String s : list) {
if(pre.test(s)) {
filterList.add(s);
}
}
return filterList;
}
public static void main(String[] args) {
List<String> list = Arrays.asList("北京","南京","天津","东京","西京");
List<String> list2 = filterString(list, (String s) -> {
return s.contains("京");
}); // 或者 s->s.contaions("京"); // 数据类型可以省略，一条语句 return {}也可以省略
System.out.println(list2);
}
}
4. 函数式接口的概述
- 只包含一个抽象方法的接口，称之为 函数式接口
- 你可以通过 Lambda 表达式来创建该接口的对象，（若 Lambda 表达式抛出一个受检异常即：非运行时异常），那么该异常需要在目标接口的抽象方法中进行声明。
- 我们可以在一个接口上使用
@Functionallnterface注解，这样就可以检查它是否是一个函数式接口。同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。 - 如果我们在某个接口上声明了
@FunctionalInterface注解，那么编译器就会按照函数式接口的定义来要求该接口，这样如果有两个抽象方法，程序编译就会报错的。所以，从某种意义上来说，只要你保证你的接口中只有一个抽象方法，你可以不加这个注解。加上就会自动进行检测的，保证安全。 - java.util.functio 包下定义了 java8 丰富的函数式接口。
Java从诞生日起就是一直倡导 “一切皆对象” ，在Java里面面向对象(OOP)编程是一切。但是随着 python,scala 等语言的兴起和新技术的挑战，Java 不得不做出调整以便支持更加广泛的技术要求，也即 java 不但可以支持 OOP 还可以支持 OOF（面向函数编程） 。
- 在 函数式编程语言当中，函数被当做一等公民对待。在将函数作为一等公民的编程语言中，Lambda 表达式的类型是函数。但是在Java8 中，有所不同。在 Java8 中，Lambda 表达式是对象，而不是函数，它们必须依附于一类特别的对象类型 —— 函数式接口 。
- 简单的说，在 Java8 中，Lambda 表达式就是一个函数式接口的实例。这就是 Lambda 表达式和函数式接口的关系。也就是说，只要一个对象时函数式接口的实例，那么该对象就可以用 Lambda 表达式来表示。所以以前用匿名实现类表示的现在都可以用 Lambda 表达式来写了。
4.1 自定义函数式接口
@FunctionalInterface
public interface MyInterface01 {
public abstract void fun();
}
函数式接口中使用泛型
@FunctionalInterface
public interface MyInterface01<T> {
public abstract T fun(T t);
}
5. Java 内置四大核心函数式接口
5.1 Consumer
| 函数式接口 | 参数类型 | 返回类型 | 作用 |
|---|---|---|---|
| Consumer |
T | void | 对类型为 T 的对象应用操作，包含抽象方法：void accept(T t) |
5.2 Supplier
| 函数式接口 | 参数类型 | 返回类型 | 作用 |
|---|---|---|---|
| Suppolier |
无 | T | 返回类型为 T 的对象，包含抽象方法为：T get() |
5.3 Function
| 函数式接口 | 参数类型 | 返回类型 | 作用 |
|---|---|---|---|
| Function<T,R> 函数型接口 | T | R | 对类型为 T 的对象应用操作，并返回结果。结果为 R 类型的对象，包含抽象方法：R apply(T t) |
5.4 Predicate
| 函数式接口 | 参数类型 | 返回类型 | 作用 |
|---|---|---|---|
| Predicate |
T | boolean | 确定类型为 T的对象是否满足某约束，并返回 boolean 值。包含抽象方法：boolean test(T t) |
5.5 其他的函数式接口
6. 方法引用
- 当要传递 给 Lambda表达式中（也就是接口中的抽象方法中），内部直接(只是)调用的是其他类中已经实现的方法，没有其他的处理语句了，就可以使用方法引用。
- 方法引用可以看做是 Lambda 表达式深层次的表达。换句话说：方法引用就是 Lambda表达式，可以理解为是 Lambda 的简写 ，同样的既然 方法引用就是 Lambda 表达式，那也就是 函数式接口的一个实例。因为：Lambda 表达式的本质：就是作为接口的实例。简单的说就是对 匿名实现接口的替换。通过方法的名字来指向一个方法，可以认为是 Lambda 表达式的一个语法糖 。
想要使用方法引用：需要满足一些条件： 实现的接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致。换句话说：就是我们接口中重写的抽象方法内部调用的其他类已经实现的方法的，这两者之间的方法的（参数列表）和 return 返回类型要一致，不然不可以使用 方法引用。
如下图
使用 方法引用的语法格式如下： 使用操作符 :: 将类(或对象) 与方法名分隔开来。
import java.util.function.Consumer;
public class MethodRefTest {
public static void main(String[] args) {
Consumer<String> consumer = System.out::println;
consumer.accept("Hello World");
}
}
常用的方法引用有如下三种情况：
- 对象::实例方法名 ： 对象名引用实例方法
- 类::静态方法名 ：类名引用静态方法
- 类:: 实例方法名 类名引用实例方法名。这里这里没有写错。
- 注意对象不可引用静态方法
这里会将上述三种情况：分别使用 Lambda 表达式 与 方法引用，匿名实现接口 处理同一个功能，通过比较这三种方式，来理解方法引用
6.1 情况1：对象::实例方法名
补充： Consumer 和 PrintStream 对应方法引用的源码：
举例：
import java.util.function.Consumer;
public class MethodRefTest {
/**
* 情况一: 对象 :: 实例方法
* Consumer 中的 void accept(T t)
* PrintStream 中的 void println(T t)
*/
public static void main(String[] args) {
// 匿名实现接口的方式：
Consumer<String> consumer1 = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println("匿名实现接口的方式: " + s);
}
};
consumer1.accept("Hello World");
// Lambda 表达式
Consumer<String> consumer2 = s-> System.out.println("Lambda 表达式: " + s);
consumer2.accept("Hello World");
// 方法引用
Consumer<String> consumer = System.out::println;
consumer.accept("Hello World");
}
}
举例：
补充：Supplier 接口中的抽象方法 与 Employee 中的方法的源码比较
import day33.java.Employee;
import java.io.PrintStream;
import java.util.function.Consumer;
import java.util.function.Supplier;
public class MethodRefTest {
/**
* Supplier 中的 T get()
* Employee 中的String getName() 两者的方法结构是一样的。
*/
public static void main(String[] args) {
// 匿名实现接口的方式：
Employee emp = new Employee(1001,"Tom",23,5600);
Supplier<String> supplier1 = new Supplier<String>() {
@Override
public String get() {
return emp.getName();
}
};
String regStr1 = supplier1.get(); // 调用其 Supplier 重写的get()抽象方法
System.out.println(regStr1);
// Lambda 表达式
Supplier<String> supplier2 = ()->emp.getName();
String regStr2 = supplier2.get(); // 调用其 Supplier 重写的get()抽象方法
System.out.println(regStr2);
// 方法引用
Supplier<String> supplier3 = emp::getName;
String regStr3 = supplier3.get(); // 调用其 Supplier 重写的get()抽象方法
System.out.println(regStr3);
}
}
6.2 情况2：类::静态方法
举例：
补充： Comparator中的compare 方法与 Integer 中的compare 方法
package blogs.blog13;
import java.util.Comparator;
public class MethodRefTest02 {
/**
* 情况二: 类 :: 静态方法
* Comparator 中的 int compare(T t1,T t2)
* Integer 中的 int compare(T t1,T t2) 两者之间的结构一致
*/
public static void main(String[] args) {
// 匿名实现接口方式
Comparator<Integer> comparator = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return Integer.compare(o1,o2);
}
};
int compare = comparator.compare(12, 21); // 调用其Comparator接口中重写的compare()抽象方法
System.out.println(compare);
// Lambda 表达式
Comparator<Integer> comparator2 = (o1,o2)->Integer.compare(o1,o2);
int compare2 = comparator2.compare(12, 21); // 调用其Comparator接口中重写的compare()抽象方法
System.out.println(compare2);
// 方法引用
Comparator<Integer> comparator3 = Integer::compareTo;
int compare3 = comparator3.compare(12, 21); // 调用其Comparator接口中重写的compare()抽象方法
System.out.println(compare3);
}
}
举例：
补充：
import java.util.function.Function;
public class MethodRefTest02 {
/**
* Function 中的 apply(T t)
* Math 中的 Long round(Double d) // 四舍五入
* 两个方法的结构一致。
*/
public static void main(String[] args) {
// 匿名实现接口的方式
Function<Double,Long> function = new Function<Double, Long>() {
@Override
public Long apply(Double d) {
return Math.round(d); // 四舍五入
}
};
Long apply = function.apply(12.3); // 调用Function 接口中的重写的apply()方法
System.out.println(apply);
// Lambda 表达式
Function<Double,Long> function2 = d->Math.round(d);
Long apply2 = function2.apply(12.3); // 调用Function 接口中的重写的apply()方法
System.out.println(apply2);
// 方法引用
Function<Double,Long> function3 = Math::round;
Long apply3 = function3.apply(12.3); // 调用Function 接口中的重写的apply()方法
System.out.println(apply3);
}
}
6.3 情况3：类::实例方法
举例：
补充： BiPredicate 中的 boolean test(T t1, T t2) 和 String 中的 boolean t1.equals(t2) 这两者之间的方法的结构也是一致的，这个比较特殊。
import java.util.function.BiPredicate;
public class MethodRefTest03 {
/**
* BiPredicate 中的 boolean test(T t1, T t2) ;
* String 中的 boolean t1.equals(t2)
*/
public static void main(String[] args) {
// 匿名实现接口的方式：
BiPredicate<String,String> biPredicate = new BiPredicate<String, String>() {
@Override
public boolean test(String s, String s2) {
return s.equals(s);
}
};
boolean test = biPredicate.test("ab", "ab"); // 调用BiPredicate接口中的 test()抽象方法
System.out.println(test);
// Lambda 表达式
BiPredicate<String, String> biPredicate2 = (s1, s2) -> s1.equals(s2);
boolean test2 = biPredicate2.test("ab", "ab"); // 调用BiPredicate接口中的 test()抽象方法
System.out.println(test2);
// 方法引用
BiPredicate<String,String> biPredicate3 = String::equals;
boolean test3 = biPredicate3.test("ab", "ab");
System.out.println(test3);
}
}
举例：
补充： Function 中的 R apply(T t) 和 Employee 中的 String getName(); 两者方法的结构是一致的
import java.util.function.Function;
public class MethodRefTest03 {
/**
* Function 中的 R apply(T t)
* Employee 中的 String getName(); 两者方法的结构是一致的
*/
public static void main(String[] args) {
Employee employee = new Employee(1001,"Jerry",23,60000);
// 匿名实现接口
Function<Employee,String> function = new Function<Employee, String>() {
@Override
public String apply(Employee employee) {
return employee.getName();
}
};
String apply = function.apply(employee); // 调用 Function 接口中的 重写的apply()抽象方法
System.out.println(apply);
// Lambda 表达式
Function<Employee,String> function2 = e->e.getName(); //一个参数，一条语句，一个返回值 () {} 可以省略
String apply2 = function2.apply(employee); // 调用 Function 接口中的 重写的apply()抽象方法
System.out.println(apply2);
// 方法引用
Function<Employee,String> function3 = Employee::getName; // Function 接口中的 apply()抽象方法
// 实际上在该重写的抽象方法中调用的是 Employee 类中的 getName()方法。
String apply3 = function3.apply(employee); // 调用 Function 接口中的 重写的apply()抽象方法
System.out.println(apply3);
}
}
7. 构造器引用
构造器引用： 与函数式接口相结合，自动与函数式接口方法兼容。
可以把构造器引用赋值给定义的方法，要求：构造器参数列表要与接口中抽象方法的参数列表一致，且方法的返回值即为构造器对应类的对象。 注意： 该接口中重写的抽象方法，仅仅只是调用了其他类中的 构造器 （new 对象）就没有其它的逻辑语句了，只有一条语句才可以使用 构造器引用。
格式如下：
ClassName::new; 类名::new
如下是通过比较：匿名实现类，Lambda 表达式，以及 构造器引用，三者之间的实现同以功能的比较，从而理解 构造器引用
举例1：
补充： Supplier中的 T get() 与 Employee 中的 无参构造器的结构
package blogs.blog13;
import day33.java.Employee;
import java.util.function.Supplier;
public class ConstructorRefTest {
/**
*
* Supplier中的 T get()
*/
public static void main(String[] args) {
// 匿名实现接口
Supplier<Employee> supplier = new Supplier<Employee>() {
@Override
public Employee get() {
return new Employee();
}
};
Employee employee = supplier.get(); // 调用 Supplier 接口中重写 get()的抽象方法
System.out.println(employee);
// Lambda 表达式
Supplier<Employee> supplier2 = ()->new Employee();
Employee employee2 = supplier2.get(); // 调用 Supplier 接口中重写 get()的抽象方法
System.out.println(employee2);
// 构造器引用
Supplier<Employee> supplier3 = Employee::new;
Employee employee3 = supplier3.get(); // 调用 Supplier 接口中重写 get()的抽象方法
System.out.println(employee3);
}
}
举例：
补充： Function中的R apply(T t) 与 Employee (int id) 的结构
import day33.java.Employee;
import java.util.function.Function;
public class ConstructorRefTest {
/**
*
* Function中的R apply(T t)
*/
public static void main(String[] args) {
// 匿名实现接口的方式
Function<Integer,Employee> function = new Function<Integer, Employee>() {
@Override
public Employee apply(Integer integer) {
return new Employee(integer);
}
};
Employee apply = function.apply(100); // 调用function接口中重写的apply()抽象方法
System.out.println(apply);
// Lambda 表达式
Function<Integer,Employee> function2 = id->new Employee(id);
Employee apply2 = function2.apply(100); // 调用function接口中重写的apply()抽象方法
System.out.println(apply2);
// 构造器引用
Function<Integer,Employee> function3 = Employee::new;
Employee apply3 = function3.apply(100); // 调用function接口中重写的apply()抽象方法
System.out.println(apply3);
}
}
举例：
补充：
import day33.java.Employee;
import java.util.function.BiFunction;
public class ConstructorRefTest {
/**
*BiFunction中的R apply(T t,U u)
*/
public static void main(String[] args) {
// 匿名实现接口的方式
BiFunction<Integer,String,Employee> biFunction = new BiFunction<Integer, String, Employee>() {
@Override
public Employee apply(Integer integer, String s) {
return new Employee(integer,s);
}
};
Employee employee = biFunction.apply(100, "Tom"); // 调用 BiFunction 接口中的 apply()抽象方法
System.out.println(employee);
// Lambda 表达式
BiFunction<Integer,String,Employee> biFunction2 = (id,name)->new Employee(id,name);
Employee employee2 = biFunction2.apply(100, "Tom"); // 调用 BiFunction 接口中的 apply()抽象方法
System.out.println(employee2);
// 构造器引用
BiFunction<Integer,String,Employee> biFunction3 = Employee::new;
Employee employee3 = biFunction3.apply(100, "Tom"); // 调用 BiFunction 接口中的 apply()抽象方法
System.out.println(employee3);
}
}
8. 数组引用
数据引用 与构造器引用基本上是一样的，稍微不同的就是在 类型[] 多了个方括号表示数组而已
格式如下：
type[] :: new;// 数据类型[]::new
举例：
补充： Function 接口源码
package blogs.blog13;
import java.util.Arrays;
import java.util.function.Function;
public class ConstructorRefTest02 {
/**
* Function中的R apply(T t)
*/
public static void main(String[] args) {
// 匿名实现接口 <> 注意泛型不能使用基本数据类型
Function<Integer,String[]> function = new Function<Integer, String[]>() {
@Override
public String[] apply(Integer integer) {
return new String[integer];
}
};
String[] apply = function.apply(5); // 调用 Function 接口中的 重写的apply()抽象方法
System.out.println(Arrays.toString(apply));
// Lambda 表达式
Function<Integer,String[]> function2 = (leng)->new String[leng];
String[] apply2 = function2.apply(5); // 调用 Function 接口中的 重写的apply()抽象方法
System.out.println(Arrays.toString(apply2));
// 数组引用
Function<Integer,String[]> function3 = String[]::new;
String[] apply3 = function3.apply(5); // 调用 Function 接口中的 重写的apply()抽象方法
System.out.println(Arrays.toString(apply3));
}
}
9. Lambda 表达式的优缺点：
Lambda表达式的优点很明显，在代码层次上来说，使代码变得非常的简洁，缺点也很明显，代码不易读，可读性比较低。
优点：
- 代码简洁，开发迅速。
- 方便函数式编程。
- 非常容易进行并行计算。
- Java 引入 Lambda，改善了集合操作，如集合的排序，遍历，优先级队列自定义大小堆等。
缺点：
- 代码可读性变差。
- 在非并行计算中，很多计算未必有传统的 for 性能要高。
- 不容易进行调试。
10. 总结:
- 重点：Lambda 表达式的本质：就是作为接口的实例。简单的说就是对 匿名实现接口的替换。
- Lambda 表达式的常见的六种语法格式
- 如果一个接口中只有一个抽象方法，(static ,default) 称为函数式接口
- 如果我们在某个接口上声明了
@FunctionalInterface注解，那么编译器就会按照函数式接口的定义来要求该接口，这样如果有两个抽象方法，程序编译就会报错的。所以，从某种意义上来说，只要你保证你的接口中只有一个抽象方法，你可以不加这个注解。加上就会自动进行检测的，保证安全。 - 方法引用，本质上就是 Lambda 表达式，而 Lambda 表达式作为函数接口(匿名实现接口重写其抽象方法)的实例，所以方法引用，也是函数式接口的实例。
- 方法引用的满足的要求：实现的接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致。换句话说：就是我们接口中重写的抽象方法内部调用的其他类已经实现的方法的，这两者之间的方法的（参数列表）和 return 返回类型要一致，不然不可以使用 方法引用。
- 方法引用的常见三种情况：对象::实例方法，类::静态方法，类::实例方法
- 构造器引用的要求：构造器参数列表要与接口中抽象方法的参数列表一致，且方法的返回值即为构造器对应类的对象。 注意： 该接口中重写的抽象方法，仅仅只是调用了其他类中的 构造器 （new 对象）就没有其它的逻辑语句了，只有一条语句才可以使用 构造器引用。
- 数据引用 与构造器引用基本上是一样的，稍微不同的就是在
类型[]多了个方括号表示数组而已 - Lambda 表达式的优缺点。
11. 最后：
限于自身水平，其中存在的错误，希望大家给予指教，韩信点兵——多多益善，谢谢大家，江湖再见，后会有期 ！！！
