Lambda表达式

概述：Lambda表达式是JDK 8开始后的一种新语法形式。

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

Lambda表达式的简化格式：

(匿名内部类被重写方法的形参列表) ->{被重写方法的方法体代码。}

注:->是语法形式，无实际含义

public class Main {
    public static void main(String[] args) {

        //简化前匿名内部类
//        Swimming s1 = new Swimming() {
//            @Override
//            public void swim() {
//                System.out.println("我游泳很快。。。");
//            }
//        };

        //使用Lambda表达式简化后
        Swimming s1  = ()-> {
            System.out.println("我游泳很快。。。");
        };
        run(s1);
        System.out.println("--------------------------");
        //继续简化
        run(()->{
            System.out.println("我游泳很快。。。");
        });
        //继续简化
        System.out.println("--------------------------");
        run(()-> System.out.println("我游泳很快。。。"));
    }

    public static void run(Swimming s){
        System.out.println("开始");
        s.swim();
        System.out.println("结束");
    }
}

@FunctionalInterface
interface Swimming{
    void swim();
}

注意:Lambda表达式只能简化函数式接口的匿名内部类的写法形式

函数式接口：

• 首先必须是接口、其次接口中有且仅有一个抽象方法的形式
• 通常我们会在接口上加上一个@FunctionalInterface注解，标记该接口必须是满足函数式接口。

好处：Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码，它可以写出更简洁、更灵活的代码，作为一种更紧凑的代码风格，使Java语言表达能力得到了提升。

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 LambdaDemo {
    public static void main(String[] args) {
        Integer[] arr = {22, 12, 45, 98, 32, 15};

        //降序排列
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });

        //Lambda表达式
        Arrays.sort(arr, (Integer o1, Integer o2)-> {
                return o2 - o1;
        });

        //参数类型可以省略不写。
        Arrays.sort(arr, (o1, o2)-> {
                return o2 - o1;
        });
        System.out.println("-----------------------------");

        JFrame win = new JFrame ( "登录界面");
        JButton btn = new JButton( "我是一个很大的按钮");
        btn.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("点击了");
            }
        });

        //Lambda表达式
        btn.addActionListener((ActionEvent e) ->{
            System.out.println("点击了");
        });

        //如果只有一个参数，参数类型可以省略，同时()也可以省略。
        btn.addActionListener(e ->{
            System.out.println("点击了");
        });

        win.add(btn);
        win.setSize( 400, 300);
        win.setVisible(true);


        //如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写，同时要省略分号!
        btn.addActionListener(e -> System.out.println("点击了"));

        //如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写。此时，如果这行代码是return语句，必须省略return不写，同时也必须省略";"不写
        Arrays.sort(arr, (o1, o2)-> o2 - o1);
    }
}

“可遇不可求”，能简化就简化，不要为了简化而简化。