Java8:新特性之Lambda基础语法

た入场券 2022-06-05 11:09 243阅读 0赞

### lambda 功能语法介绍 ###

> Java8 引入了一个新的操作符 “->” ,该操作符称为 箭头操作符,lambda 操作符 , 该箭头将表达试分为俩部分,分别是操作符左边,和操作符右边,

*  左边:方法参数()
 *  右边:所需执行的功能,一般我们称为操作体

#### 需要注意的是,lambda 只支持一个抽象方法的接口,列如 Runnable 接口 ####

从今以后,这部分接口我们可以不用在使用接口的匿名内布类了,可以使用Lambda 来代替, 下面演示一个案例,让我们更直观的感受Lambda给我们带来的好处

@Test
        public void Test_Lambda(){
            /** * 创建一个线程,以前的写法 */
            Runnable r1 = new Runnable() {
                @Override
                public void run() {
                    System.out.println("这是匿名内不类的写法");
                }
            };
    
    // 调用方法r1
            r1.run();
    
            /** * * 这是lambda 表达式的写法 */
            Runnable r2 = () -> System.out.println("这是lambda 表达式的写法");
            //调用r2
            r2.run();
        }

方法执行输出结果如下  
![这里写图片描述][SouthEast]

我们发现,虽然功能一摸一样,但是lambda 的代码简洁了很多,我们来分析刚刚的Lambda 表达式

//这是Lambda表达式
    () -> System.out.println("这是lamdba 表达式的写法");
    
    // "->" lambda 操作符 
    可以把表达式看成俩部分    
    
     - 左边 :  ()    方法参数 Runnable 的run 方法是没有参数的,所以括号里不用填参,
     - 右边 : 操作体,也就是需要执行的语句,

> 在java8 以前,我们在匿名内布类里面使用局部变量,局部变量需要被final 修饰 , 但是在java8中,我们在匿名内不类里面使用

![这里写图片描述][SouthEast 1]

上图我们可以看出,int a 没有被final修饰,匿名函数了也可以使用,在下图中,我们可以发现,匿名内部类里并不能操作局部变量,所以我们可以得出结论,java8中局部依旧使用了final修饰,只不过没有在页面上显示出来,  
![这里写图片描述][SouthEast 2]

### 案例演示 ###

*  无参,无返回值(演示接口 Runnable)  
    刚才我们演示了 无参数,无返回值的方法 , 所以我们就不再演示 无参数,无返回值的方法了,  
    语法 () -> System.out.println(“操作语句”)
 *  有参,无返回值(演示接口 Consumer)  
    ![这里写图片描述][SouthEast 3]

> 分析代码前,我们来看consumer接口  
> ![这里写图片描述][SouthEast 4]  
> Consumer 内部只有一个方法,这符合Lambda的使用要求,方法里只有一个参数,参数类型可以自定义,

分析完接口,我们回头来分析Lambda表达式

Consumer<String> c = (t) -> System.out.println(t.replace("z",""));
    
    //从表达试我们可以看出,我们定义的参数类型是String类型的参数,  
    
    // 我们把表达式分为左右俩边,以 "->"号来划分 
    左边:
    (t)  其实相当于形参,我们定义的参数是String类型的,所以 t也是String类型的参数,  相当是(String t),
    
    右边: System.out.println(t.replace("z",""));
    因为有了String 类型的形参,所以我们可以在方法体(操作体里面使用),可以使用String类的API

> 补充 :如果方法只有一个参数,那么括号可以不写,下面这样写也是可以的,  
> Consumer c = t -> System.out.println(t.replace(“z”,”“));

看运行结果  
![这里写图片描述][SouthEast 5]

--------------------

*  有多个参有返回值,多条操作语句(演示接口 Comparator)  
    首先,我们先来看看Comparator接口,里面只有一个compara的抽象方法,符合Lambda 使用要求,  
    ![这里写图片描述][SouthEast 6]

语法介绍:

//如果有返回值的话,并且有多条操作语句那么操作体需要使用大括号引起来,
    Comparator<Integer> c = (x,y) -> {};

代码演示

@Test
        public void Test_Lambda03(){
            Comparator<Integer> c = (x,y) -> {
                System.out.println("这是一个比较大小的接口");
                return Integer.compare(x,y);
            };
    
            int compare = c.compare(7, 6);
            System.out.println(compare);
        }

运行结果如下

![这里写图片描述][SouthEast 7]

--------------------

*  有参数,有返回值,但是只有一条操作语句,

语法介绍 :  
ruturn 跟 大括号都可以省略不写,

Comparator<Integer> c = (x,y) -> Integer.compare(x,y);

代码演示

@Test
        public void Test_Lambda04(){
            Comparator<Integer> c = (x,y) -> Integer.compare(x,y);
            int compare = c.compare(7, 6);
            System.out.println(compare);
        }

运行结果如下  
![这里写图片描述][SouthEast 8]

--------------------

*  Lambda的参数列表的参数类型可以不写,因为JVM可以从上下文推断出参数类型,即类型推断,其实我们以前也用过这种类似的语法,

@Test
        public void Test_Lambda05(){
                          // 这里参数也是没有类型的,jvm也是从上下文获取参数类型的
           String[] arr = {
       "aaa","bbb","ccc"};
        }

扩展

> Java8中对类型推断也进行了升级,看下面的代码

@Test
        public void Test_Lambda06(){
      //在jdk1.8以前,这样写是通过不了编译的,但是在jdk1.8以后,完全没问题!因为它通过执行方法的目标方法获取了上下文的类型,
            Test_07(new HashMap<>());
        }
    
        public void Test_07(Map<String,String> map){
            System.out.println(map);
        }

--------------------

### 结论: ###

#### 1. ####

> “->”的左侧只有一个参数的话 括号可以省,类型可以省  
> “->”的右侧只有一条执行语句的话大括号可以省,

如果没有省的话语法如下

(Object x) ->\{“这里写操作语句”\}  
建议省掉了,,,因为jdk1.8升级类型推断不就是想让我们偷点懒嘛,我们要领情, 嘿嘿(其实是懒)  
省调后的语句为  
(x) -> “这里写操作语句”

2.  
需要注意的是,Lambda的使用需要函数试接口的支持, 那么什么是函数试接口的,其实就是只有一个抽象方法的接口, java提供了一种判断函数试接口的注解 @FunctionalInterface,如果接口没有报错,那么这个接口就是函数试接口,

3.最后我们来做一个小案例  
要求,对一个数进行运算

*  创建一个函数试接口

@FunctionalInterface
    public interface LambdaFun {
    
        int Count();
    }

测试类

public class Demo {
    
        @Test
        public void Test_01(){
            int demo = Demo(5, (X) -> X * X);
            System.out.println("demo="+demo);
        }
    
        public int Demo(Integer num,LambdaFun lf){
            return lf.Count(num);
        }
    }

jdk1.8的Lambda特性就讲到这里,如果有什么地方讲的地方不好,欢迎指出

[SouthEast]: /images/20220605/24e556d239df4ddc83cabfea41ef8134.png
[SouthEast 1]: /images/20220605/227e9b7fef224327a5677e0d0e34c595.png
[SouthEast 2]: /images/20220605/e3031e5dbc004f0d95251698e58de4cc.png
[SouthEast 3]: /images/20220605/6074cbfa4018466991fdc63db8ff7a06.png
[SouthEast 4]: /images/20220605/531e0f6525314dd788f0ba831afc27b2.png
[SouthEast 5]: /images/20220605/18fc456cf51247319cf81aea5a116251.png
[SouthEast 6]: /images/20220605/a405820eee534f3fab10250586f2bc93.png
[SouthEast 7]: /images/20220605/a7b41c3580df42678c768913052bbd80.png
[SouthEast 8]: /images/20220605/a917b64492f04d8ba400e403f655166c.png