Lambda表达式

Lambda表达式的标准格式

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

• 一些参数

• 一个箭头

• 一段代码

Lambda表达式的标准格式为：

(参数类型 参数名称) -> { 代码语句 }

格式说明

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

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

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

线程案例演示

public class Test {
    public static void main(String[] args) {
        /*
            Lambda表达式的标准格式:
                - 标准格式:  (参数列表)->{ 代码 }
                - 格式说明:
                    - 小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。
                    - ->是新引入的语法格式，代表指向动作。
                    - 大括号内的语法与传统方法体要求基本一致。

                - 案例演示:
                    线程案例
                    比较器案例

              格式解释:
                1.小括号中书写的内容和接口中的抽象方法的参数列表一致
                2.大括号中书写的内容和实现接口中的抽象方法的方法体一致
                3.箭头就是固定的
         */
        //  线程案例
        // 面向对象编程思想:
        // 匿名内部类方式创建线程执行任务
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程需要执行的任务代码1...");
            }
        });
        t1.start();

        // 函数式编程思想: Lambda表达式
        Thread t2 = new Thread(()->{ System.out.println("线程需要执行的任务代码2...");});
        t2.start();

    }

}

比较器案例演示

public class Test {
    public static void main(String[] args) {
        /*
            Lambda表达式的标准格式:
                - 标准格式:  (参数列表)->{ 代码 }
                - 格式说明:
                    - 小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。
                    - ->是新引入的语法格式，代表指向动作。
                    - 大括号内的语法与传统方法体要求基本一致。

                - 案例演示:
                    线程案例
                    比较器案例

              格式解释:
                1.小括号中书写的内容和接口中的抽象方法的参数列表一致
                2.大括号中书写的内容和实现接口中的抽象方法的方法体一致
                3.箭头就是固定的
         */
        //  比较器案例
        // Collections.sort(List<?> list,Comparator<?> comparator);
        List<Integer> list = new ArrayList<>();
        Collections.addAll(list,100,200,500,300,400);
        System.out.println("排序之前的集合:"+list);// [100, 200, 500, 300, 400]

        // 面向对象编程思想:
        /*Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                // 降序: 后减前
                return o2 - o1;
            }
        });
        System.out.println("排序之后的集合:"+list);// [500, 400, 300, 200, 100]*/

        // 函数式编程思想:Lambda表达式
        Collections.sort(list,(Integer o1, Integer o2)->{return o2 - o1;});
        System.out.println("排序之后的集合:"+list);// [500, 400, 300, 200, 100]


    }

}

Lambda表达式省略规则

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

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

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

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

线程案例演示

public class Demo_线程演示 {
    public static void main(String[] args) {
       
        //Lambda表达式省略规则
        Thread t2 = new Thread(()-> System.out.println("执行了"));
        t2.start();
    }
}

比较器案例演示

public class Demo_比较器演示 {
    public static void main(String[] args) {
        //比较器
        ArrayList<Integer> list = new ArrayList<>();
        //添加元素
        list.add(324);
        list.add(123);
        list.add(67);
        list.add(987);
        list.add(5);
        System.out.println(list);

        //Lambda表达式
        Collections.sort(list, ( o1,  o2)-> o2 - o1);

        //打印集合
        System.out.println(list);
    }
}

Lambda的前提条件

• 使用Lambda必须具有接口，且要求接口中的抽象方法有且仅有一个。(别的方法没有影响)

• 使用Lambda必须具有上下文推断。

  • 如果一个接口中只有一个抽象方法，那么这个接口叫做是函数式接口。

    @FunctionalInterface这个注解 就表示这个接口是一个函数式接口

Lambda的表现形式

• 变量形式

• 参数形式

• 返回值形式

public class Demo {
    public static void main(String[] args) {
        /*
            Lambda表达式其实就是用来替换函数式接口的对象
            Lambda表达式的标准格式
            Lambda表达式的省略格式
            Lambda的几种使用形式: 使用场景
                1.变量的形式:变量的类型为函数式接口类型,那么可以赋值一个Lambda表达式
                2.参数的形式:方法的形参类型为函数式接口类型,那么就可以传入一个Lambda表达式
                3.返回值的形式:方法的返回值类型为函数式接口类型,那么就可以返回一个Lambda表达式

         */
        // 变量的形式:
        Runnable r = ()->{System.out.println("变量的形式");};// 需要Runnable函数式接口的对象,所以可以使用Lambda表达式替换
        r.run();

        // 参数的形式:
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"赵丽颖","马尔扎哈","杨颖","波多野结衣");
        System.out.println("排序之前:"+list);// 排序之前:[赵丽颖, 马尔扎哈, 杨颖, 波多野结衣]
        Collections.sort(list,(String o1,String o2)->{return o2.length() - o1.length();});
        System.out.println("排序之后:"+list);// 排序之后:[波多野结衣, 马尔扎哈, 赵丽颖, 杨颖]
    }

    // 返回值的形式: 方法的返回值类型为函数式接口类型,那么就可以返回一个Lamdba表达式
    public static Comparator<String> getComparator(){
        return (String o1,String o2)->{return o2.length() - o1.length();};
    }

    public static Runnable getRunnable(){
        return ()->{System.out.println("====");};
    }
}