JavaSE Lambda表达式(JDK1.8新特性)

Posted 2020-08-10

在前面有一篇写到了Lambda表达式,现在可以给你们介绍什么是Lambda表达式

现在有很多老程序员都不喜欢这个函数式编程思想

　　主要就一点 : 老程序员习惯了 面向过程 写程序,而Lambda表达式是 面向结果 不注重过程

那么Lambda有什么优点 : 

• 操作简单
• 代码优化 

缺点 : 

• 非常不易读

Lambda标准格式

Lambda省去面向对象的条条框框，格式由3个部分组成：

• 一些参数

• 一个箭头

• 一段代码

Lambda表达式的标准格式为 : ( 参数类型 参数名称 ) -> { 代码语句 }

格式说明：

• 小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。

• ->是新引入的语法格式，代表指向动作。

• 大括号内的语法与传统方法体要求基本一致。

Lambda的使用前提-函数式接口

Lambda的语法非常简洁，完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意：

1. 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。无论是JDK内置的Runnable、Comparator接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。

2. 使用Lambda必须具有上下文推断。也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

@FunctionalInterface注解

与@Override注解的作用类似，Java 8中专门为函数式接口引入了一个新的注解：@FunctionalInterface。该注解可用于一个接口的定义上：

1 @FunctionalInterface
2 public interface MyFunctionalInterface {
3     void myMethod();
4 }

一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。

没有错Lambda表达式必须用在接口上并且此接口内有且只有一个抽象方法 才能够使用Lambda表达式

下面拿Runnable接口来演示 无参 写法

 1 /*
 2     Lambda表达式的标准格式，由三部分组成：
 3     1、一些参数
 4     2、一个箭头→
 5     3、一段代码
 6     Lambda表达式格式：
 7         ( 参数列表 )->{ 重写的方法体代码 }
 8     格式说明：
 9     (): 接口中抽象方法的参数列表，没有参数就空着不写。有参数就写出参数，多少参数使用逗号分隔
10     ->: 将参数列表中的参数，传递给方法体
11     {}：重写接口中抽象方法的具体代码。
12 
13 */
14 public class LambdaDemo {
15     public static void main(String[] args) {
16         // 使用匿名内部类完成线程任务
17         new Thread(new Runnable() {
18             @Override // 线程任务 重写run方法
19             public void run() {
20                 System.out.println("使用匿名内部类..完成多线程执行...");
21             }
22         }).start();
23 
24         // 代码优化，使用Lambda表达式
25         new Thread( () -> {
26                 System.out.println("使用匿名内部类..完成多线程执行...");
27             }
28         ).start();
29     }
30 }

我们再拿 Arrays.sort(数组,Comparator接口) 来演示 有参 写法 (这个是对数组排序)

 1 // 演示有参有返回值 Lambda表达式
 2 public class LambdaDemo {
 3     public static void main(String[] args) {
 4         Person[] ps = {
 5                 new Person("如来佛祖",90000),
 6                 new Person("观音菩萨",18),
 7                 new Person("孙悟空",700)
 8         };
 9 
10         // 需求：将数组中的对象，按年龄从小到大的方式排序
11 
12 //        // 使用匿名内部类的方式完成
13 //        Arrays.sort(ps, new Comparator<Person>() {
14 //            @Override // 重写比较的方法，按年龄排序
15 //            public int compare(Person o1, Person o2) {
16 //                return o1.age - o2.age;
17 //            }
18 //        });
19 
20         // 使用Lambda方式完成升序排列
21         Arrays.sort( ps , ( Person p1 , Person p2 ) -> {
22             return p1.age - p2.age;
23         });
24 
25         // 打印排序后的数组
26         for( Person p : ps ) {
27             System.out.println( p );
28         }
29     }
30 }

Lambda省略格式

省略规则

在Lambda标准格式的基础上，使用省略写法的规则为：

1. 小括号内参数的类型可以省略；

2. 如果小括号内有且仅有一个参数，则小括号可以省略；

3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。

 我们来拿 Collections.sort(List集合,Comparator接口) 来演示 有参 写法 (这个是对List集合排序)

 

 1 public class lists{
 2 
 3     
 4     public static void main(String[] args) {
 5         ArrayList<Integer> list = new ArrayList<>();
 6         list.add(5);
 7         list.add(2);
 8         list.add(3);
 9         list.add(7);
10         for (Integer integer : list) {
11             System.out.print(integer+"  ");
12         }
13 
14         System.out.println();
15         //按降序排列
16         Collections.sort(list,(o1,o2) ->o2 - o1);
17         for (Integer integer : list) {
18             System.out.print(integer+"  ");
19         }
20     }
21 }