Lambda表达式

使用Lambda表达式的前提: 函数式接口
函数式接口: 接口中有且仅有一个抽象方法,该接口就是函数接口
使用套路:
- 判断是否可以使用Lambda表达式---->使用前提
- 如果可以使用,那么就直接写上()->{}
- 填充小括号中的内容--->与函数式接口中抽象方法的形参列表一致
- 填充大括号中的内容--->其实就是实现函数式接口中抽象方法的方法体
省略规则
- 小括号中参数类型可以省略不写
- 如果小括号中只有一个参数,那么小括号也可以省略
- 如果大括号中只有一条语句,那么大括号,分号,return关键字也可以省略(注意要一起省略)

函数式编程思想概述

面向对象编程思想

面向对象强调的是对象 , “必须通过对象的形式来做事情”，相对来讲比较复杂,有时候我们只是为了做某件事情而不得不创建一个对象 , 例如线程执行任务,我们不得不创建一个实现Runnable接口对象,但我们真正希望的是将run方法中的代码传递给线程对象执行

函数编程思想

在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情”。相对而言，面向对象过分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法——强调做什么，而不是以什么形式做。例如线程执行任务 , 使用函数式思想 , 我们就可以通过传递一段代码给线程对象执行,而不需要创建任务对象

Lambda表达式的体验

需求: 创建并启动线程,执行打印100次HelloWorld

实现Runnable接口的方式创建线程执行任务
匿名内部类方式创建线程执行任务
- 以上2种方式,其实都是通过Runnable的实现类对象来传递任务给线程执行
- 不通过实现类对象传递任务给线程执行--->函数式编程
Lambda方式创建线程执行任务

package com.jcli;

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            System.out.println("这是第"+i+"次打印HelloWorld---");
        }
    }
}

package com.jcli;

public class Test02 {
    public static void main(String[] args) {
        // 需求: 创建并启动线程,执行打印100次HelloWorld
        MyRunnable mr = new MyRunnable();
        new Thread(mr).start();
        // 通过实现Runnable方式: 必须创建实现类重写run方法,必须创建实现类对象,传入任务到线程中
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <= 100; i++) {
                    System.out.println("匿名这是第" + i + "次打印HelloWorld！！！");
                }
            }
        }).start();
        // 匿名内部类: 直接传入Runnable的匿名内部类(Runnable的实现类对象),传入任务到线程中
        //- 以上2种方式,其实都是通过Runnable的实现类对象来传递任务给线程执行

        //- 不通过实现类对象传递任务给线程执行呢--->函数式编程
        new Thread(() -> {
            for (int i = 0; i <= 100; i++) {
                System.out.println("Lambda这是第" + i + "次打印HelloWorld！！！");
            }
        }).start();
    }
}

Lambda表达式的标准格式

Lambda的使用前提条件:

接口必须是函数式接口才可以使用Lambda表达式

函数式接口: 接口中有且仅有一个抽象方法,该接口就是函数接口

// 函数式接口
public interface A{
    void method1();
}
// 函数式接口
public interface B{
    void method1();
    public default void method2(){}
}
// 不是函数式接口
public interface C{
    void method1();
    void method2(){}
}
// 不是函数式接口
public interface C{
    public default void method(){}
}

是函数式接口可以使用@FunctionalInterface注解进行标识,否则不可以使用该注解标识

标准格式
- 格式:
格式说明
- 小括号中形参列表与函数式接口中抽象方法的形参列表一致(形参名可以不一致,但形参类型,顺序,个数必须一致)
- ->固定写法,表示指向动作,代表小括号中的参数传递到大括号中使用
- 大括号中的代码其实就是和之前重写函数式接口中抽象方法的方法体一致

案例演示

Runnable函数式接口

package com.jcli;

public class Test03 {
    public static void main(String[] args) {
    //    创建并启动线程
        new Thread(()->{
            System.out.println("lambda表达式方式···");
        }).start();
    }
}

Comparator函数式接口

package com.jcli;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Test04 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(500);
        list.add(200);
        list.add(400);
        list.add(300);
        list.add(100);
        System.out.println("排序之前:"+list);
        // 指定规则排序--->升序
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });
        System.out.println("升序之后:"+list);
        Collections.sort(list,(Integer i1,Integer i2)->{return i2-i1;});
        System.out.println("降序之后:"+list);
    }
}

Lambda表达式省略格式

省略规则

Lambda表达式小括号中的参数类型可以省略不写
如果Lambda表达式小括号中只有一个参数,那么小括号也可以省略不写

如果Lambda表达式大括号中只有一条语句,那么大括号,return关键字,以及语句分号都可以省略(必须一起省略)

package com.jcli;

import java.util.ArrayList;
import java.util.Collections;

public class Test05 {
    public static void main(String[] args) {
        // 创建并启动线程----Lambda标准格式
        new Thread(() -> {
            System.out.println("Lambda表达式方式1...");
        }).start();
        // 创建并启动线程----Lambda省略格式
        new Thread(() -> System.out.println("Lambda表达式方式2```")).start();

        ArrayList<Integer> list = new ArrayList<>();
        list.add(500);
        list.add(200);
        list.add(400);
        list.add(300);
        list.add(100);
        System.out.println("排序之前:" + list);
        // Lambda标准格式
        Collections.sort(list, (Integer i1, Integer i2) -> {
            return i2 - i1;
        });
        System.out.println("升序之后:" + list);
        // 指定规则排序--->降序
        // Lambda省略格式
        Collections.sort(list, (i1, i2) -> i1 - i2);
        System.out.println("降序之后:" + list);

    }
}

Lambda的表现形式

Lambda的表现形式: Lambda表达式以后会出现在哪些位置

参数形式: 传入Lambda表达式作为实参---->最常见

package com.jcli;

import java.util.ArrayList;
import java.util.Collections;

public class Test07 {
    public static void main(String[] args) {
        // 参数形式:  传入Lambda表达式作为实参---->常见
        // 创建并启动线程
        new Thread(()->{
            System.out.println("参数形式...");
        }).start();


        ArrayList<Integer> list = new ArrayList<>();
        list.add(500);
        list.add(300);
        list.add(400);
        list.add(100);
        list.add(200);
        System.out.println("排序之前:"+list);
        // 指定规则排序--->降序
        // Lambda标准格式
        // Collections.sort(list,(Integer i1,Integer i2)->{ return i2 - i1;});

        // Lambda省略格式
        Collections.sort(list,(i1, i2)-> i2 - i1);
        System.out.println("排序之后:"+list);
    }
}

返回值形式: 返回一个Lambda表达式(返回值)---->常见

package com.jcli;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Test08 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(500);
        list.add(300);
        list.add(400);
        list.add(100);
        list.add(200);
        System.out.println("排序之前:"+list);
        // 排序--->降序
        Collections.sort(list,getComparator());
        System.out.println("排序之后:"+list);
    }

    // 定义一个方法,返回值类型为Comparator<Integer>
    public static Comparator<Integer> getComparator(){
        return (Integer o1,Integer o2)->{return o2 - o1;};
    }
}

变量形式: 赋值一个Lambda表达式---->不常见

package com.jcli;

public class Test06 {
    public static void main(String[] args) {
        // 变量形式: 赋值一个Lambda表达式---->不常见
        Runnable r1 = ()->{System.out.println("变量形式使用Lambda表达式1...");};
        Runnable r2 = ()->System.out.println("变量形式使用Lambda表达式2...");
        new Thread(r1).start();
        new Thread(r2).start();

    }
}