Day38：Lambda表达式

Lambda表达式

1.1 概述

Lambda是JDK8开始后的一种新语法形式。

作用：简化函数式匿名内部类的代码写法。

简化格式：

/*部类被重写方法的参数)->{
    被重写方法的方法体代码
}
->为语法格式，无任何含义
*/

注意：

• Lambda表达式只能简化函数式接口的匿名内部类

那什么是函数式接口？

首先必须是接口、其次要求接口内只有一个抽象方法

有什么好处呢？

简化代码，提升语言表达能力。

1.2 Lambda表达式简化初体验

public class LambdaDemo {
    public static void main(String[] args) {
        //学习如何使用Lambda表达式               Lamdbda只能简化  函数式接口的匿名内部类

//第一步：先创建函数式匿名内部类
             /*
             Animals a=new Animals() {//用多态的方式接收它
             @Override
             public void run() {
                System.out.println("喵喵在奔跑");
             }//必须重写所有抽象方法

             };//匿名内部类本质其实是一个继承类的子类对象或者是接口的实现类对象,
             */

//第二步：简化匿名内部类
        Animals a=() ->{System.out.println("喵喵在奔跑");};
        go(a);//方法在下面

        System.out.println("=================================");

//第三步：继续简化
          //匿名内部类是可以作参的
           /*go(new Animals() {
            @Override
            public void run() {
                System.out.println("喵喵在奔跑");
            }
        });
            */
        go(() ->{System.out.println("喵喵在奔跑");});
    }

    //函数式接口
    @FunctionalInterface//我们可以在接口上加一个注释：@FunctionalInterface 这样约束接口必须是函数式
    interface Animals{//要求是接口
        void run();//只含有一个抽象方法
    }
    //接口实现类对象作参的方法
    public static void go(Animals a){
        System.out.println("开始奔跑");
        a.run();
        System.out.println("结束奔跑");
    }
}

开始奔跑
喵喵在奔跑
结束奔跑
=================================
开始奔跑
喵喵在奔跑
结束奔跑

1.3 实战简化

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Arrays;
import java.util.Comparator;

public class LambdaDemo01 {
    public static void main(String[] args) {
        //建立一个数组
        Integer[] a={10,2,5,22,543,1};
        //自定义排序方法使之降序
           /*Arrays.sort(a, new Comparator<Integer>() {//我们发现这个比较器就是一个函数式匿名内部类
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });
        System.out.println(Arrays.toString(a));
            */
        //简化上面代码
        Arrays.sort(a,(Integer o1, Integer o2) ->{return o1-o2;});

        System.out.println("===================================");
        JFrame win = new JFrame("登录界面");//创建窗口
        JButton btn=new JButton("我是按钮");//创建按钮
        win.setSize(400,300);
        win.setVisible(true);
        win.add(btn);
        btn.addActionListener(new ActionListener() {//绑定一个监听器
            @Override//这是一个函数式匿名内部类
            public void actionPerformed(ActionEvent e) {
                System.out.println("有人点我哟");
            }
        });
        //简化上面的函数式匿名内部类
        /*
        btn.addActionListener((ActionEvent e) ->{System.out.println("有人点我哟");});
         */
    }
}

1.4 Lambda表达式的省略规则

建立在Lambda表达式的基础上继续简化

• 参数类型可以省略不写
• 如果只有一个参数，参数类型可以不写，同时（）也可以省略
• 如果Lambda表达式的方法体代码只有一行代码，则可以省略大括号不写，但同时要省略分号
• 如果Lambda表达式的方法体代码只有一行代码，则可以省略大括号不写，与此同时，此代码是return语句，必须省略return，同时也要省略分号

我们把上面实战的代码进行简化：

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Arrays;
import java.util.Comparator;

public class LambdaDemo02 {
    public static void main(String[] args) {
        //建立一个数组
        Integer[] a={10,2,5,22,543,1};
        //自定义排序方法使之降序
           /*Arrays.sort(a, new Comparator<Integer>() {//我们发现这个比较器就是一个函数式匿名内部类
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });
        System.out.println(Arrays.toString(a));
            */
        //简化上面代码
        //Arrays.sort(a,(Integer o1, Integer o2) ->{return o1-o2;});
        //进一步简化  参数类型可以省略不写
        //Arrays.sort(a,(o1,o2) ->{return o1-o2;});
        //再进一步简化   如果Lambda表达式的方法体代码只有一行代码，则可以省略大括号不写，与此同时，此代码是return语句，必须省略return，同时也要省略分号
        Arrays.sort(a,(o1,o2) -> o1-o2);

        System.out.println("===================================");
        JFrame win = new JFrame("登录界面");//创建窗口
        JButton btn=new JButton("我是按钮");//创建按钮
        win.setSize(400,300);
        win.setVisible(true);
        win.add(btn);
        /*
        btn.addActionListener(new ActionListener() {//绑定一个监听器
            @Override//这是一个函数式匿名内部类
            public void actionPerformed(ActionEvent e) {
                System.out.println("有人点我哟");
            }
        });

         */

        //简化上面的函数式匿名内部类
        /*
        btn.addActionListener((ActionEvent e) ->{System.out.println("有人点我哟");});
         */
        //进一步简化  如果Lambda表达式的方法体代码只有一行代码，则可以省略大括号不写，但同时要省略分号
        btn.addActionListener( e->System.out.println("有人点我哟"));
    }
}