Lambda表达式超详细总结
Lambda表达式介绍
Java 8的一个大亮点是引入Lambda表达式，使用它设计的代码会更加简洁。通过Lambda表达式，可以替代我们以前经常写的匿名内部类来实现接口。Lambda表达式本质是一个匿名函数；
体验Lambda表达式
我们通过一个小例子来体验下Lambda表达式；
我们定义一个计算接口，只有一个方法add；
使用原始方式调用接口：
public class LambdaTest {//定义一个cal接口interface Cal {int add(int a, int b);}public static void main(String[] args) {//使用原始方式调用接口Cal cal = new Cal(){@Overridepublic int add(int a, int b) {return a+b;}};System.out.println("a+b等于："+cal.add(1,2));}
}这个是我们以前的实现，匿名内部类，然后调用执行；
使用lambda表达式的方式：
public class LambdaTest {//定义一个cal接口interface Cal {int add(int a, int b);}public static void main(String[] args) {//使用lambda表达式的方式Cal cal = (int a,int b) ->{return a+b;};System.out.println("a+b等于：" + cal.add(1, 2));}
}匿名内部类，直接改成了：
Cal cal = (int a,int b) ->{return a+b;};简洁多了；
是不是感觉Lambda表达式挺强大，
接下来我们来看看Lambda表达式的语法吧；
Lambda表达式语法
我们看下这个Lambda表达式：
Cal cal = (int a,int b) ->{return a+b;};这个本质是一个函数；
一般的函数类似如下：
int add(int a,int b){return a+b;
}有返回值，方法名，参数列表，方法体
Lambda表达式函数的话，只有参数列表，和方法体；
( 参数列表 ) -> { 方法体 }
说明：
( ) ：用来描述参数列表；
{ } ： 用来描述方法体；
-> ：Lambda运算符，可以叫做箭头符号，或者goes to
Lambda表达式语法细讲
我们搞一个案例，接口方法参数，无参，单个参数，两个参数，有返回值，没有返回值；
这六种情况都罗列下：
interface If1{/*** 无参数无返回值*/void test();
}interface If2{/*** 单个参数无返回值* @param a*/void test(int a);
}interface If3{/*** 两个参数无返回值* @param a* @param b*/void test(int a,int b);
}interface If4{/*** 无参数有返回值* @return*/int test();
}interface If5{/*** 单个参数有返回值* @param a* @return*/int test(int a);
}interface If6{/*** 多个参数有返回值* @param a* @param b* @return*/int test(int a,int b);
}我们用Lambda表达式实现：
/*** 无参数无返回值*/If1 if1 = ()->{System.out.println("无参数无返回值...");};if1.test();/*** 单个参数无返回值* @param a*/If2 if2 = (int a)->{System.out.println("单个参数无返回值，a="+a);};if2.test(3);/*** 两个参数无返回值* @param a* @param b*/If3 if3 = (int a,int b)->{System.out.println("单个参数无返回值，a+b="+(a+b));};if3.test(3,2);/*** 无参数有返回值* @return*/If4 if4 = ()->{System.out.print("无参数有返回值...");return 100;};System.out.println(if4.test());/*** 单个参数有返回值* @param a* @return*/If5 if5 = (int a)->{System.out.print("单个参数有返回值...");return a;};System.out.println(if5.test(200));/*** 多个参数有返回值* @param a* @param b* @return*/If6 if6 = (int a,int b)->{System.out.print("多个参数有返回值...");return a+b;};System.out.println(if6.test(2,3));运行输出：
无参数无返回值...
单个参数无返回值，a=3
单个参数无返回值，a+b=5
无参数有返回值...100
单个参数有返回值...200
多个参数有返回值...5Lambda表达式精简语法
Lambda语法注意点：
1,参数类型可以省略
2,假如只有一个参数，()括号可以省略
3,如果方法体只有一条语句，{}大括号可以省略
4,如果方法体中唯一的语句是return返回语句，那省略大括号的同事return也要省略
改写实例：
/*** 无参数无返回值*/If1 if1 = () -> System.out.println("无参数无返回值...");if1.test();/*** 单个参数无返回值* @param a*/If2 if2 = a -> System.out.println("单个参数无返回值，a="+a);if2.test(3);/*** 两个参数无返回值* @param a* @param b*/If3 if3 = (a,b) -> System.out.println("单个参数无返回值，a+b="+(a+b));if3.test(3,2);/*** 无参数有返回值* @return*/If4 if4 = () -> 100;System.out.println(if4.test());/*** 单个参数有返回值* @param a* @return*/If5 if5 = a -> {System.out.print("单个参数有返回值...");return a;};System.out.println(if5.test(200));/*** 多个参数有返回值* @param a* @param b* @return*/If6 if6 = (a,b) -> a+b;System.out.println(if6.test(2,3));方法引用
有时候多个lambda表达式实现函数是一样的话，我们可以封装成通用方法，以便于维护；
这时候可以用方法引用实现：
语法是：对象::方法
假如是static方法，可以直接 类名::方法
实例如下：
interface If5{/*** 单个参数有返回值* @param a* @return*/int test(int a);}public int test(int a){return a-2;}public static void main(String[] args) {LambdaTest3 lambdaTest3 = new LambdaTest3();If5 if5 = lambdaTest3::test;System.out.println("单个参数有返回值："+if5.test(3));}构造方法引用
如果函数式接口的实现恰好可以通过调用一个类的构造方法来实现，
那么就可以使用构造方法引用;
语法：类名::new
实例：
先定义一个Dog实体，实现无参和有参构造方法；
public class Dog {private String name;private int age;public Dog() {System.out.println("无参构造方法");}public Dog(String name, int age) {System.out.println("有参构造方法");this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Dog{" +"name='" + name + '\'' +", age=" + age +'}';}
}在定义两个接口：
interface DogService{Dog getDog();}interface DogService2{Dog getDog(String name,int age);
}测试：
//普通方式DogService dogService=()->{return new Dog();};dogService.getDog();//简化方式DogService dogService1=()->new Dog();dogService1.getDog();//构造方法引用DogService dogService2=Dog::new;dogService2.getDog();// 构造方法引用 有参DogService2 dogService3=Dog::new;dogService3.getDog("小米",11);执行结果：
无参构造方法
无参构造方法
无参构造方法
有参构造方法综合实例
下面我们通过几个lambda操作集合的综合实例，来深入体验下Lambda表达式用法；
Lambda表达式排序：
//定义一个List集合
List list=new ArrayList<>();
//往集合中添加值
list.add(new Dog("aa",1));
list.add(new Dog("bb",4));
list.add(new Dog("cc",3));
list.add(new Dog("dd",2));
list.add(new Dog("ee",5));
//排序
System.out.println("lambda集合排序：");
list.sort((o1, o2) -> o1.getAge()-o2.getAge());
System.out.println(list);
// 遍历集合
System.out.println("lambda遍历集合：");
list.forEach(System.out::println); 运行输出：
lambda集合排序：
[Dog{name='aa', age=1}, Dog{name='dd', age=2}, Dog{name='cc', age=3}, Dog{name='bb', age=4}, Dog{name='ee', age=5}]
lambda遍历集合：
Dog{name='aa', age=1}
Dog{name='dd', age=2}
Dog{name='cc', age=3}
Dog{name='bb', age=4}
Dog{name='ee', age=5}我们来分析下集合的sort方法，
sort方法里有一个Comparator接口，再点进去看下：
我们通过lambda就可以轻松实现排序：
(o1,o2)->o1.getAge()-o2.getAge()
再看下集合的forEach方法，点进去：
有个消费者Consumer接口，再点进去：
接口里有个接口参数的accept的方法；
所以我们直接方法引用 直接输出每次的遍历值即可；
System.out::println
@FunctionalInterface注解
前面我们会发现Consumer接口，Comparator接口都有@FunctionalInterface注解；
这个注解是函数式接口注解，所谓的函数式接口，当然首先是一个接口，然后就是在这个接口里面只能有一个抽象方法。
这种类型的接口也称为SAM接口，即Single Abstract Method interfaces
特点：
1、接口有且仅有一个抽象方法
2、允许定义静态方法
3、允许定义默认方法
4、允许java.lang.Object中的public方法
5、该注解不是必须的，如果一个接口符合"函数式接口"定义，那么加不加该注解都没有影响。加上该注解能够更好地让编译器进行检查。如果编写的不是函数式接口，但是加上了@FunctionInterface，那么编译器会报错
实例：
// 正确的函数式接口
@FunctionalInterface
public interface TestInterface {// 抽象方法public void sub();// java.lang.Object中的public方法public boolean equals(Object var1);// 默认方法public default void defaultMethod(){}// 静态方法public static void staticMethod(){}
}// 错误的函数式接口(有多个抽象方法)
@FunctionalInterface
public interface TestInterface2 {void add();void sub();
}系统内置函数式接口
Java8的推出，是以Lambda重要特性，一起推出的，其中系统内置了一系列函数式接口；
在jdk的java.util.function包下，有一系列的内置函数式接口：
比如常用的Consumer，Comparator，Predicate，Supplier等；
Lambda表达式视频教程
B站视频教程在线地址：
Java8 Lambda表达式视频教程(无废话版)_哔哩哔哩_bilibili