?个人主页：island1314
?个人专栏：java学习
⛺️ 欢迎关注：?点赞 ??留言 ?收藏 ? ? ?
1. 背景 ?
? Lambda 表达式 是JDK8新增的特性，Lambda 表达式 可以取代大部分匿名内部类，写出更优雅的Java代码，尤其在集合的遍历和其他集合操作中，可以将函数作为一个方法的参数，也就是函数作为参数传递到方法中，极大地优化代码结构JDK也提供了大量的内置函数式接口供开发者使用，使得 Lambda 表达式 的运用更加方便、高效。
Lambda 表达式（Lambda expression）可以看作是一个匿名函数，基于数学中的λ演算得名，也可称为闭包（Closure）Lambda 表达式 的使用场景：用以简化接口实现2. 基本使用 ?
? 1. 语法格式
? Lambda表达式的基本语法：由 参数列表（parameters）、箭头符号(一>) 和方法体（expression 或者 statements）组成
paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。
->：可理解为“被用于” 的意思
方法体：可以是表达式也可以代码块，是函数式接口里方法的实现。
代码块可返回一个值或者什么都不返回，这里的代码块等同于方法的方法体。
如果是表达式，也可以返回一个值或者什么都不返回。
其中，表达式会被执行，然后返回执行结果；语句块中的语句会被依次执行，就像方法中的语句一样。
Lambda表达式常用的语法格式如下所示：
| 语法格式 | 描述 |
| () -> System.out.println("Hello IsLand1314"); | 无参数，无返回值 |
| (x) -> System.out.println(x); | 有一个参数，无返回值 |
| x -> System.out.println(x); | 若只有一个参数，小括号可以省略不写 |
| Comparator<Integer>com = (x，y) -> { System.out.priniln("函数式接口"); return Integer,compare(x，y); }; | 有两个以上的参数，有返回值，并且Lambda方法体中有多条语句 |
| Comparator<Integer>com = (x，y) -> Integer,compare(x，y);); | 若Lambda方法体中只有一条语句，return和大括号都可以省略不写 |
| (Integer x, Integer y) -> Integer.compare(x, y): | Lambda表达式的参数列表的数据类型可以省略不写，因为 Java 虚拟机的编译器可以通过上下文推断出数据类型，即 "类型推断" |
? 2. 函数式接口
? 虽然说，Lambda 表达式 可以在⼀定程度上简化接口的实现。但是，并不是所有的接口都可以使用lambda表达式来简洁实现的。
? Lambda 表达式 毕竟只是⼀个匿名方法。当实现的接口中的方法过多或者多少的时候，lambda表达式都是不适用的。
lambda表达式，只能实现函数式接口，函数式接口定义：一个接口有且只有一个抽象方法如下：
//有且只有一个实现类必须要实现的抽象方法，所以是函数式接口interface Test{ public void test();}补充：
? @FunctionalInterface
是⼀个注解，用在接口之前，判断这个接口是否是⼀个函数式接口。如果是函数式接口，没有任何问题。如果不是函数式接口，则会报错功能类似于 @Override@FunctionalInterfaceinterface NoParameterNoReturn {//注意：只能有一个方法void test();}但是这种方式也是可以的：
@FunctionalInterfaceinterface NoParameterNoReturn {void test();default void test2() {System.out.println("JDK1.8新特性，default默认方法可以有具体的实现");}}注意：
如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口如果我们在某个接口上声明了 @FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求该接口，这样如果有两个抽象方法，程序编译就会报错的 所以，从某种意义上来说，只要你保证你的接口中只有一个抽象方法，你可以不加这个注解。加上就会自动进行检测的Lambda 表达式 只能简化函数式接口的匿名内部类的写法
? 3. 具体使用
? 我们在上面提到过，Lambda表达式本质是一个匿名函数，函数的方法是：返回值 方法名 参数列表 方法体
在 Lambda 表达式 中我们只需要关心：参数列表 方法体首先，我们实现准备好几个接口：
//无返回值无参数@FunctionalInterfaceinterface NoParameterNoReturn { void test();}//无返回值一个参数@FunctionalInterfaceinterface OneParameterNoReturn { void test(int a);}//无返回值两个参数@FunctionalInterfaceinterface MoreParameterNoReturn { void test(int a,int b);}//有返回值无参数@FunctionalInterfaceinterface NoParameterReturn { int test();}//有返回值一个参数@FunctionalInterfaceinterface OneParameterReturn { int test(int a);}//有返回值多个参数@FunctionalInterfaceinterface MoreParameterReturn { int test(int a,int b);}我们在上面提到过，Lambda可以理解为：Lambda就是匿名内部类的简化，实际上是创建了一个类，实现了接口，重写了接口的方法 。
没有使用 Lambda 表达式 的时候的调用方式NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn(){ @Override public void test() { System.out.println("hello"); }};noParameterNoReturn.test();public class Test { public static void main(String[] args) { NoParameterNoReturn n = ()->{ System.out.println("无参数无返回值"); }; n.test(); OneParameterNoReturn o = (a)-> { System.out.println("无返回值一个参数 "+a); }; o.test(666); MoreParameterNoReturn m = (int a,int b)->{ System.out.println("无返回值两个参数 "+a+" "+b); }; m.test(666,999); System.out.println("================"); NoParameterReturn n1 = ()->{ return 666; }; int ret1 = n1.test(); System.out.println(ret1); System.out.println("================"); OneParameterReturn o1 = (int a)->{ return a; }; int ret2 = o1.test(999); System.out.println(ret2); System.out.println("================"); MoreParameterReturn m1 = (int a,int b)-> { return a+b; }; int ret3 = m1.test(10,90); System.out.println(ret3); }}// 打印结果：无参数无返回值无返回值一个参数 666无返回值两个参数 666 999================666================999================100? Lambda 表达式 的语法还可以精简，显得非常有逼格，但是可读性就非常差，之前我们上面说过 Lambda 表达式 的语法格式表格。
参数类型可以省略，如果需要省略，每个参数的类型都要省略。参数的小括号里面只有一个参数，那么小括号可以省略如果方法体当中只有一句代码，那么大括号可以省略如果方法体中只有一条语句，其是return语句，那么大括号可以省略，且去掉return关键字public class Test { public static void main(String[] args) { MoreParameterNoReturn moreParameterNoReturn = (a, b)->{ System.out.println("无返回值多个参数，省略参数类型："+a+" "+b); }; moreParameterNoReturn.test(20,30); OneParameterNoReturn oneParameterNoReturn = a ->{ System.out.println("无参数一个返回值,小括号可以省略："+ a); }; oneParameterNoReturn.test(10); NoParameterNoReturn noParameterNoReturn = ()->System.out.println("无参数无返回值，方法体中只有 一行代码"); noParameterNoReturn.test(); //方法体中只有一条语句，且是return语句 NoParameterReturn noParameterReturn = ()-> 40; int ret = noParameterReturn.test(); System.out.println(ret); }}// 结果如下：无返回值多个参数，省略参数类型：20 30无参数一个返回值,小括号可以省略：10无参数无返回值，方法体中只有 一行代码40可能还不直观，一般来说，大家只要向下面这样使用就行
interface T{ public int test(String name,int age);}public class Test { public static void main(String[] args) { T t = (name, age) -> { System.out.println(name + " "+ age + " 岁了"); return age + 1; }; int age = t.test("qian", 18); System.out.println(age); }}// 输出如下：qian 18 岁了194. 变量捕获
? Lambda 表达式中存在变量捕获 ，了解了变量捕获之后，我们才能更好的理解 Lambda 表达式 的作用域 。Java当中的匿名类中，会存在变量捕获。
? 1. 匿名内部类变量捕获
匿名内部类就是没有名字的内部类 。在前面的博客——>【Java 学习】：内部类详解 中提到了匿名内部类中变量的捕获。
而我们这里只是为了说明变量捕获，所以，匿名内部类只要会使用就好匿名内部类中：一定是程序在运行的过程当中没有发生改变的量那么下面我们来，下面就来看看匿名内部类的使用及其变量捕获
//有参 有返回值class T{ public void func(){ System.out.println("func()"); }}public class Test { public static void main(String[] args) { int a = 100; new T(){ // a = 666; // 如果把 a 在匿名内部类修改，就会报错 @Override public void func() { System.out.println("a= " + a); }}.func(); }}// 输出a= 100注意： 上面在匿名内部类注释的 a = 666，代码中会报错
原因如下：
匿名内部类中可以访问外部方法的局部变量（如 a），但这个变量必须是 final 或 隐式 final，这里的 a 由于没有被修改，因此是隐式 final，所以可以安全访问。
你注释掉的代码 a = 666; 会导致编译错误，因为局部变量 a 在 Lambda 或匿名内部类中不可修改，必须保持其初始值
? 2. Lambda的变量捕获
在 Lambda 表达式当中也可以进行变量的捕获
Lambda 表达式的变量捕获，同样也是不能捕获放生改变的，如果发生改变就会报错具体我们看一下代码
public class Test { @FunctionalInterface interface NoParameterNoReturn { void test(); } public static void main(String[] args) { int a = 10; NoParameterNoReturn noParameterNoReturn = ()->{ // a = 99; error System.out.println("捕获变量："+a); }; noParameterNoReturn.test(); }}注意事项：
这里类似于局部内部类、匿名内部类，依然存在闭包的问题。如果在 Lambda 表达式中，使用到了局部变量，那么这个局部变量会被隐式的声明为 final。是⼀个常量，不能修改值。5. 函数引用
? Lambda 表达式是为了简化接口的实现的。在Lambda 表达式中，不应该出现比较复杂的逻辑。
如果在 Lambda 表达式中出现了过于复杂的逻辑，会对程序的可读性造成非常大的影响。如果在 Lambda 表达式中需要处理的逻辑比较复杂，⼀般情况会单独的写⼀个方法。在 Lambda 表达式中直接引用这个方法即可。函数引用：引用⼀个已经存在的方法，使其替代lambda表达式完成接口的实现
? 1. 静态方法引用
语法
类::静态方法案例如下：
interface T{ int test(int a,int b);}class Cal{ public static int add(int a,int b ){ return a + b; }}public class Test { public static void main(String[] args) { //实现多个参数，一个返回值的接口 //对一个静态方法的引用，语法：类::静态方法 T t = Cal::add; System.out.println(t.test(4,5)); }}// 输出结果：9注意事项
在引用的方法后面，不要添加小括号。引用的这个方法，参数（数量、类型）和返回值，必须要跟接口中定义的⼀致
? 2. 非静态方法引用
语法
对象::非静态方法案例如下：
interface T{ int test(int a,int b);}public class Test { private static class Cal{ public int add(int a, int b) { return a+b; } } public static void main(String[] args) { // //对非静态方法的引用，需要使用对象来完成 // 两种方法 // 方法一 Cal cal = new Cal(); T t = cal::add; // 方法二： //T t = new Cal()::add; System.out.println(t.test(4,5)); }}注意事项
在引用的方法后面，不要添加小括号。引用的这个方法， 参数（数量、类型） 和 返回值， 必须要跟接口中定义的⼀致
? 3. 构造方法引用
使用场景
如果某⼀个函数式接口中定义的方法，仅仅是为了得到⼀个类的对象。此时我们就可以使用构造方法的引用，简化这个方法的实现。语法：
类名::new案例如下：
public class Test { private static class Student { String name; int age; //无参构造 public Student() { System.out.println("学生对象的无参构造"); } //有参构造 public Student(String name, int age) { System.out.println("学生对象的有参构造"); this.name = name; this.age = age; } } //定义一个函数式接口,用以获取无参的对象 @FunctionalInterface private interface GetStudent { //若此方法仅仅是为了获得一个Student对象，而且通过无参构造去获取一个Student对象作为返回值 Student s(); } //定义一个函数式接口,用以获取有参的对象 @FunctionalInterface private interface GetStudentWithParameter { //若此方法仅仅是为了获得一个Student对象，而且通过有参构造去获取一个Student对象作为返回值 Student a(String name, int age); } // 测试 public static void main(String[] args) { //lambda表达式实现接口 GetStudent lm = Student::new; //引用到学生类中的无参构造方法，获取到一个学生对象 Student s1 = lm.s(); System.out.println("学生的名字：" + s1.name + " 学生的年龄：" + s1.age); //学生的名字：null 学生的年龄：0 System.out.println("--------------------------------"); GetStudentWithParameter lm2 = Student::new;//引用到Student类中的有参构造，来获取一个学生对象 Student s2 = lm2.s("IsLand", 18); System.out.println("学生的名字：" + s2.name + " 学生的年龄：" + s2.age);//学生的名字：IsLand 学生的年龄：18 }}这里 Student::new 是对 Student 类中无参构造方法的引用，使用它来实现 GetStudent 接口的 test() 方法。因此，lm.test() 会调用 Student 类的无参构造器，返回一个 Student 对象。在这种情况下，Student 对象的 name 和 age 字段会保持默认值：null 和 0。
注意事项：可以通过接口中的方法的参数， 区分引用不同的构造方法。
6. Lambda 在集合中的使用
? 为了能够让Lambda和Java的集合类集更好的一起使用，集合当中，也新增了部分接口，以便与Lambda表达式对接。
多提一句：要用Lambda遍历集合就一定要看懂源码
注意：Collection的forEach()方法是从接口 java.lang.Iterable 拿过来的
? 1. Collection 接口
forEach() 方法演示
? forEach()方法遍历集合。如果要打印元素，它需要的实现 Consumer接口，同时要实现重写 accept() 方法，它会把数组里的每一个元素都交给 accept()方法。
该方法在接口 Iterable 当中，原型如下：
default void forEach(Consumer< ? super T> action) {Objects.requireNonNull(action);for (T t : this) {action.accept(t);}}public class Test { public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();list.add("Hello");list.add("IsLand");list.add("Hello");list.add("lambda");// 两种遍历遍历list.forEach(new Consumer<String>() {@Overridepublic void accept(String str) {//简单遍历集合中的元素。System.out.print(str + " ");}});System.out.println();System.out.println("----------------------------");//表示调用一个，不带有参数的方法，其执行花括号内的语句，为原来的函数体内容。list.forEach(s -> {System.out.print(s + " ");});}}// 输出：Hello IsLand Hello lambda ----------------------------Hello IsLand Hello lambda ? 2. List 接口
sort()方法的演示
sort方法源码：该方法根据c指定的比较规则对容器元素进行排序
public void sort(Comparator< ? super E> c) {final int expectedModCount = modCount;Arrays.sort((E[]) elementData, 0, size, c);if (modCount != expectedModCount) {throw new ConcurrentModificationException();}modCount++;}使用示例：
public class Test { public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();list.add("Hello");list.add("IsLand");list.add("Hello");list.add("lambda");// 两种排序方式list.sort(new Comparator<String>() {@Overridepublic int compare(String s1, String s2) {//注意这里比较长度return s1.length() - s2.length();}});System.out.println(list);System.out.println("----------------------------");// 修改为 Lambda 表达式//调用带有2个参数的方法，且返回长度的差值list.sort((s1, s2)->s1.length() - s2.length());System.out.println(list);}}// 输出如下：[Hello, Hello, IsLand, lambda]----------------------------[Hello, Hello, IsLand, lambda]? 3. Arrays 接口
public class Test { public static void main(String[] args) {String[] a = {"program", "creek", "is", "a", "java", "site"};Arrays.sort(a, (m,n)->Integer.compare(m.length(), n.length())) ;System.out.println("Lambda 语句体只有一条语句，参数类型可推断: " + Arrays.toString(a));Arrays.sort(a, (String m, String n)->{if( m.length() > n.length()) return -1;else return 0;});System.out.println("Lambda 语句体有多条语句，参数类型可推断: " + Arrays.toString(a));}}// 输出结果如下：Lambda 语句体只有一条语句，参数类型可推断: [a, is, java, site, creek, program]Lambda 语句体有多条语句，参数类型可推断: [program, creek, java, site, is, a]? 4. Map 接口
HashMap 的 forEach()
该方法原型如下：
default void forEach(BiConsumer< ? super K, ? super V> action) {Objects.requireNonNull(action);for (Map.Entry<K, V> entry : entrySet()) {K k;V v;try {k = entry.getKey();v = entry.getValue();}catch (IllegalStateException ise) {// this usually means the entry is no longer in the map.throw new ConcurrentModificationException(ise);}action.accept(k, v);}}代码示例
public class Test { public static void main(String[] args) { HashMap<Integer, String> map = new HashMap<>(); map.put(1, "Hello");map.put(2, "IsLand"); map.put(3, "Hello");map.put(4, "lambda"); map.forEach(new BiConsumer<Integer, String>(){ @Override public void accept(Integer k, String v){ System.out.println(k + "=" + v); } }); System.out.println("--------------------------------------");// 改为 Lambda 表达式map.forEach((k, v) -> System.out.println(k + "=" + v)); }}// 运行结果如下：1=Hello2=IsLand3=Hello4=lambda--------------------------------------1=Hello2=IsLand3=Hello4=lambda
7. 小结
Lambda表达式的优点很明显，在代码层次上来说，使代码变得非常的简洁。缺点也很明显，代码不易读
优点：
简化代码：使得代码更加简洁，尤其是在处理集合、并行处理和事件监听时。增强可读性：通过将代码行为和逻辑传递给方法，减少了冗长的匿名类实现。支持函数式编程：Lambda 使得 Java 更加符合函数式编程范式，增强了代码的表达能力。能够与 Stream API 结合：Lambda 表达式与 Java 8 引入的 Stream API 配合使用，可以更方便地进行集合的操作（如过滤、映射、聚合等）。缺点：
调试困难：Lambda 表达式是匿名的，难以在调试时逐步跟踪。尤其是复杂的 Lambda 表达式可能使得代码的可调试性下降。过度使用 Lambda：如果 Lambda 表达式过于复杂或滥用，可能会导致代码的可读性下降，尤其是当 Lambda 的行为变得不直观时。性能问题：虽然 Lambda 表达式的引入让代码更加简洁，但在某些情况下，Lambda 的性能可能不如传统的匿名类或普通方法调用，因为每次调用 Lambda 都涉及到对象的创建（比如生成函数式接口的代理）。Lambda表达式有什么使用前提： 必须是接口的匿名内部类，接口中只能有一个抽象方法
隐式 final：如果局部变量没有明确声明为 final，但在 Lambda 表达式中没有改变它的值，则编译器会隐式将其视为 final