Lambda表达式
在说Lambda表达式之前我们了解一下函数式编程思想，在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情”。
相对而言，面向对象过分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法——强调做什么，而不是以什么形式做。 下面以匿名内部类创建线程的代码案例详细说明这个问题。
public class ThreadDemo {
public static void main(String[] args) {
//实现Runnable方式创建简单线程--传统匿名内部类形式
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("开启了一个线程----匿名内部类");
}
}).start();
//实现Runnable方式创建简单线程--Lambda表达式形式
new Thread(()-> System.out.println("开启了一个线程---Lambda表达式")).start();
}
}
运行结果：
开启了一个线程----匿名内部类
开启了一个线程---Lambda表达式
对以上代码的分析：
对于 Runnable 的匿名内部类用法，可以分析出几点内容：
Thread 类需要 Runnable 接口作为参数，其中的抽象 run 方法是用来指定线程任务内容的核心；
为了指定 run 的方法体，不得不需要 Runnable 接口的实现类；
为了省去定义一个 RunnableImpl 实现类的麻烦，不得不使用匿名内部类；
必须覆盖重写抽象 run 方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错；
而实际上，似乎只有方法体才是关键所在。
传统的写法比Lambda表达式写法显而易见代码繁琐了许多，而且2者实现目的是相同的。
我们真的希望创建一个匿名内部类对象吗？不。我们只是为了做这件事情而不得不创建一个对象。我们真正希望做的事情是：将 run 方法体内的代码传递给 Thread 类知晓。
传递一段代码——这才是我们真正的目的。而创建对象只是受限于面向对象语法而不得不采取的一种手段方式。
那，有没有更加简单的办法？如果我们将关注点从“怎么做”回归到“做什么”的本质上，就会发现只要能够更好地达到目的，过程与形式其实并不重要。
这时就要用到函数式编程思想了，只关注“做什么”，而不是以什么方式做！！
了解过函数式编程思想后，我们要尝试着转变思想，从面向对象的"怎么做"转换为函数式编程思想的“做什么”，只有思想有了转变，才能更好的了解和学习Lambda表达式。
什么是Lambda表达式？
Lambda 是一个匿名函数，我们可以把 Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。
作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升 。（2014年3月Oracle所发布的Java 8（JDK 1.8）中，加入了Lambda表达式 ）
Lambda表达式语法：( ) -> { }
Lambda 表达式在Java 语言中引入了一个新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为 Lambda 操作符或剪头操作符。它将 Lambda 分为
两个部分：
左侧 （）： 指定了 Lambda 表达式需要的所有参数
右侧 {}： 指定了 Lambda 体，即 Lambda 表达式要执行的功能。
Lambda表达式标准格式：(参数类型 参数名称) ‐> { 代码语句 }
格式进一步说明：
小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。
-> 是新引入的语法格式，代表指向动作。
大括号内的语法与传统方法体要求基本一致
Lambda表达式如何使用呢？
Lambda表达式的使用是有前提的，必须要满足2个条件：1.函数式接口 2.可推导可省略。
函数式接口是指一个接口中只有一个必须被实现的方法。这样的接口都满足一个注解@FunctionalInterface
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
可推导可省略是指上下文推断，也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例 。
下面我们自定义一个函数式接口，使用Lambda表达式完成功能。
public class Demo {
public static void main(String[] args) {
invokeCook(()->{
System.out.println("做了一盘红烧鱼....");
});
}
//需要有个以函数式接口为参数的方法
public static void invokeCook(Cook cook) {
cook.makeFood();
}
}
//自定义函数式接口
@FunctionalInterface
interface Cook{
void makeFood();
}
以上案例是函数式接口以及Lambda表达式最简单的定义和用法。
针对Lambda表达式还可以做出进一步的省略写法：
1.小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
所以上面的代码可以简写为：
invokeCook(()-> System.out.println("做了一盘红烧鱼...."));
Lambda表达式有多种语法，下面我们了解一下。（直接写省略形式）
1.无参，无返回值，Lambda体只需一条语句
Runnable r = ()->System.out.println("hell lambda");
2.Lambda表达式需要一个参数，无返回值
Consumer c = (str)-> System.out.println(args);
当Lambda表达式只有一个参数时，参数的小括号可以省略
Consumer c = str-> System.out.println(args);
3.Lambda表达式需要2个参数，并且有返回值
BinaryOperator<Long> bo = (num1,num2)->{ return num1+num2;};
当Lambda体中只有一条语句时，return 和 大括号、分号可以同时省略。
BinaryOperator<Long> bo = (num1,num2)-> num1+num2;
有没有发现我们没写参数类型，Lambda表达式依然可以正确编译和运行，这是因为Lambda表达式拥有的类型推断功能。
上述 Lambda 表达式中的参数类型都是由编译器推断得出的。 Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，
在后台推断出了参数的类型。 Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的“类型推断” 。
Lambda表达式还具有延迟执行的作用：改善了性能浪费的问题，代码说明。
public class Demo {
public static void main(String[] args) {
String str1 = "hello";
String str2 = "Lambda";
String str3 = "表达式";
log(1,str1+str2+str3);
}
public static void log(int level,String str) {
if (level == 1) {
System.out.println(str);
}
}
}
在上面代码中，存在的性能浪费问题是如果 输入的level！=1，而str1+str2+str3作为log方法的第二个参数还是参与了拼接运算，但是我们的实际想法应该是不满足level=1的条件就不希望str1+str2+str3进行拼接运算，下面通过Lambda表达式来实现这个功能。
public class Demo {
public static void main(String[] args) {
String str1 = "hello";
String str2 = "Lambda";
String str3 = "表达式";
log(1,()->str1+str2+str3);
}
public static void log(int level,Message message) {
if (level == 1) {
System.out.println(message.message());
}
}
}
@FunctionalInterface
interface Message {
String message();
}
以上代码功能相同，Lambda表达式却实现了延迟，解决了性能浪费，下面我们来验证一下：
public class Demo {
public static void main(String[] args) {
String str1 = "hello";
String str2 = "Lambda";
String str3 = "表达式";
log(2,()->{
System.out.println("lambda 执行了");
return str1+str2+str3;
});
}
public static void log(int level,Message message) {
if (level == 1) {
System.out.println(message.message());
}
}
}
@FunctionalInterface
interface Message {
String message();
}
此时在输入level=2的条件时，如果Lambda不延迟加载的话会执行输出语句输出lambda 执行了，而实际是控制台什么也没输出，由此验证了Lambda表达式的延迟执行。
在Lambda表达式的应用过程中还有一种比较常用的方式：方法引用。方法引用比较难以理解，而且种类也较多，需要多费脑筋去理解。
Lambda表达式应用之 ：方法引用
方法引用也是有前提的，分别为：
1.前后的参数名一致，
2.Lambda表达式的方法体跟对应的方法的功能代码要一模一样
方法引用种类可以简单的分为4+2种，4种跟对象和类有关，2种跟构造方法有关。下面一一说明。
跟对象和类有关的方法引用：
1.对象引用成员方法
格式：对象名 :: 成员方法名 （双冒号 :: 为引用运算符，而它所在的表达式被称为方法引用）
原理：将对象的成员方法的参数和方法体，自动生成一个Lambda表达式。
1 public class Demo {
2 public static void main(String[] args) {
3 Assistant assistant = new Assistant();
4 work(assistant::dealFile);//对象引用成员方法（注意是成员的方法名，没有小括号）
5 }
6 //以函数式接口为参数的方法
7 public static void work(WokerHelper wokerHelper) {
8 wokerHelper.help("机密文件");
9 }
10 }
11 //助理类，有个成员方法
12 class Assistant{
13 public void dealFile(String file) {
14 System.out.println("帮忙处理文件："+file);
15 }
16 }
17 //函数式接口，有个需要实现的抽象方法
18 @FunctionalInterface
19 interface WokerHelper {
20 void help(String file);
21 }
2.类调用静态方法
格式：类名 :: 静态方法名
原理：将类的静态方法的参数和方法体，自动生成一个Lambda表达式。
public class Demo {
public static void main(String[] args) {
methodCheck((str)->StringUtils.isBlank(str)," ");//非省略模式
methodCheck(StringUtils::isBlank," ");//省略模式 类名调用静态方法
}
//
public static void methodCheck(StringChecker stringChecker,String str) {
System.out.println(stringChecker.checkString(str));
}
}
//定义一个类包含静态方法isBlank方法
class StringUtils{
public static boolean isBlank(String str) {
return str==null || "".equals(str.trim());//空格也算空
}
}
//函数式接口，有个需要实现的抽象方法
@FunctionalInterface
interface StringChecker {
boolean checkString(String str);
}
3.this引用本类方法
格式：this :: 本类方法名
原理：将本类方法的参数和方法体，自动生成一个Lambda表达式。
public class Demo {
public static void main(String[] args) {
new Husband().beHappy();
}
}
class Husband{
public void buyHouse() {
System.out.println("买套房子");
}
public void marry(Richable richable) {
richable.buy();
}
public void beHappy() {
marry(this::buyHouse);//调用本类中方法
}
}
//函数式接口，有个需要实现的抽象方法
@FunctionalInterface
interface Richable {
void buy();
}
4.super引用父类方法
格式：super :: 父类方法名
原理：将父类方法的参数和方法体，自动生成一个Lambda表达式。
public class Demo {
public static void main(String[] args) {
new Man().sayHello();
}
}
//子类
class Man extends Human{
public void method(Greetable greetable) {
greetable.greet();
}
@Override
public void sayHello() {
method(super::sayHello);
}
}
//父类
class Human{
public void sayHello() {
System.out.println("Hello");
}
}
//函数式接口，有个需要实现的抽象方法
@FunctionalInterface
interface Greetable {
void greet();
}
跟构造方法有关的方法引用：
5.类的构造器引用
格式： 类名 :: new
原理：将类的构造方法的参数和方法体自动生成Lambda表达式。
public class Demo {
public static void main(String[] args) {
printName("张三",(name)->new Person(name));
printName("张三",Person::new);//省略形式，类名：：new引用
}
public static void printName(String name, BuildPerson build) {
System.out.println(build.personBuild(name).getName());
}
}
//函数式接口，有个需要实现的抽象方法
@FunctionalInterface
interface BuildPerson {
Person personBuild(String name);
}
//实体类
class Person{
String name;
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
'}';
}
}
6.数组的构造器引用
格式： 数组类型[] :: new
原理：将数组的构造方法的参数和方法体自动生成Lambda表达式。
public class Demo {
public static void main(String[] args) {
int[] array1 = method(10, (length) -> new int[length]);
int[] array2 = method(10, int[]::new);//数组构造器引用
}
public static int[] method(int length, ArrayBuilder builder) {
return builder.buildArray(length);
}
}
//函数式接口，有个需要实现的抽象方法
@FunctionalInterface
interface ArrayBuilder {
int[] buildArray(int length);
}
到此，Lambda表达式的基本知识就算学完了。
有人可能会提出疑问，Lambda表达式使用前要定义一个函数式接口，并在接口中有抽象方法，还要创建一个以函数式接口为参数的方法，之后调用该方法才能使用Lambda表达式，感觉并没有省很多代码！！哈哈，之所以有这样的想法，那是因为是我们自定义的函数式接口，而JDK1.8及更高的版本都给我们定义函数式接口供我们直接使用，就没有这么繁琐了。接下来我们学习一下JDK为我们提供的常用函数式接口。
常用的函数式接口
1.Supplier<T> 供给型接口
@FunctionalInterface
public interface Supplier<T> {
T get();
}
用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口，这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。
如果要定义一个无参的有Object返回值的抽象方法的接口时，可以直接使用Supplier<T>,不用自己定义接口了。
public class Demo {
public static void main(String[] args) {
String str1 = "hello";
String str2 = "lambda";
String s = method(() -> str1 + str2);
System.out.println("s = " + s);
}
public static String method(Supplier<String> supplier) {
return supplier.get();
}
}
2.Consumer<T> 消费型接口
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
//合并2个消费者生成一个新的消费者，先执行第一个消费者的accept方法，再执行第二个消费者的accept方法
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
}
Consumer<T> 接口则正好相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型参数决定 。 如果要定义一个有参的无返回值的抽象方法的接口时，可以直接使用Consumer<T>,不用自己定义接口了。
public class Demo {
public static void main(String[] args) {
consumerString(string -> System.out.println(string));
consumerString(System.out::println);//方法引用形式
}
public static void consumerString(Consumer<String> consumer) {
consumer.accept("fall in love!");
}
}
3.Predicate<T> 断定型接口
@FunctionalInterface
public interface Predicate<T> {
//用来判断传入的T类型的参数是否满足筛选条件，满足>true
boolean test(T t);
//合并2个predicate成为一个新的predicate---->并且&&
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
//对调用的predicate原来的结果进行取反---->取反 ！
default Predicate<T> negate() {
return (t) -> !test(t);
}
//合并2个predicate成为一个新的predicate---->或||
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
}
Predicate<T>接口主要是对某种类型的数据进行判断，返回一个boolean型结果。可以理解成用来对数据进行筛选。
当需要定义一个有参并且返回值是boolean型的方法时，可以直接使用Predicate接口中的抽象方法
1 //1.必须为女生；
2 //2. 姓名为4个字。
3 public class Demo {
4 public static void main(String[] args) {
5 String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };
6 List<String> list = filter(array,
7 str-> "女".equals(str.split(",")[1]),
8 str->str.split(",")[0].length()==3);
9 System.out.println(list);
10 }
11 private static List<String> filter(String[] array, Predicate<String> one, Predicate<String> two) {
12 List<String> list = new ArrayList<>();
13 for (String info : array) {
14 if (one.and(two).test(info)) {
15 list.add(info);
16 }
17 }
18 return list;
19 }
20 }
4.Function<T,R> 函数型接口
@FunctionalInterface
public interface Function<T, R> {
//表示数据转换的实现。T--->R
R apply(T t);
//合并2个function，生成一个新的function，调用apply方法的时候，先执行before，再执行this
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
//合并2个function，生成一个新的function，调用apply方法的时候，先执行this，再执行after
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
}
Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。有进有出，所以称为“函数Function”。
该接口可以理解成一个数据工厂，用来进行数据转换，将一种数据类型的数据转换成另一种数据. 泛型参数T：要被转换的数据类型（原料），泛型参数R：想要装换成的数据类型（产品）。
public class Demo {
public static void main(String[] args) {
String str = "赵丽颖,20";
int age = getAgeNum(str,
string ->string.split(",")[1],
Integer::parseInt,//str->Integer.parseInt(str);
n->n+=100);
System.out.println(age);
}
//实现三个数据转换 String->String, String->Integer,Integer->Integer
private static int getAgeNum(String str, Function<String, String> one,
Function<String, Integer> two,
Function<Integer, Integer> three) {
return one.andThen(two).andThen(three).apply(str);
}
}
至此，常用的四个函数式接口已学习完毕。
总结一下函数式表达式的延迟方法与终结方法：
延迟方法：默认方法都是延迟的。
终结方法：抽象方法都是终结的。
| 接口名称 | 方法名称 | 抽象方法/默认方法 | 延迟/终结 |
| Supplier | get | 抽象 | 终结 |
| Consumer | accept | 抽象 | 终结 |
| andThen | 默认 | 延迟 | |
| Predicate | test | 抽象 | 终结 |
| and | 默认 | 延迟 | |
| or | 默认 | 延迟 | |
| negate | 默认 | 延迟 | |
| Function | apply | 抽象 | 终结 |
| andThen | 默认 | 延迟 |
函数式接口在Stream流中的应用较为广泛，其中Stream流中的过滤Filter方法使用到了Predicate的判定，map方法使用到了Function的转换，将一个类型的流转换为另一个类型的流。
482
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
