Lambda表达式

函数式编程思想概述 
在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情”。相对而言，面向对象过 分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法——强调做什么，而不是以 什么形式做。
面向对象的思想: 做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情.
函数式编程思想: 只要能获取到结果,谁去做的,怎么做的都不重要,重视的是结果,不重视过程 

package com.itheima.demo03.Lambda;
/*
    创建Runnable接口的实现类,重写run方法,设置线程任务
 */
public class RunnableImpl implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" 新线程创建了");
    }
}

以上为接口实现类

最简的代码中这季节将r塞到了Thread()中。

执行结果：

Thread-0 新线程创建了
Thread-2 新线程创建了
Thread-1 新线程创建了

Process finished with exit code 0

体验lambda更优写法

 

匿名内部类的好处与弊端 
一方面，匿名内部类可以帮我们省去实现类的定义；另一方面，匿名内部类的语法——确实太复杂了！

语义分析 
仔细分析该代码中的语义， Runnable 接口只有一个 run 方法的定义：
public abstract void run();
即制定了一种做事情的方案（其实就是一个函数）：
无参数：不需要任何条件即可执行该方案。

无返回值：该方案不产生任何结果。

代码块（方法体）：该方案的具体执行步骤。

同样的语义体现在 Lambda 语法中，要更加简单：
 

() ‐> System.out.println("多线程任务执行！")

• 前面的一对小括号即 run 方法的参数（无），代表不需要任何条件；
• 中间的一个箭头代表将前面的参数传递给后面的代码；
• 后面的输出语句即业务逻辑代码。

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

1. 一些参数
2. 一个箭头
3. 一段代码

Lambda表达式的标准格式为：

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

 

Lambda表达式的无参数无返回值的练习

需求:
    给定一个厨子Cook接口，内含唯一的抽象方法makeFood，且无参数、无返回值。
    使用Lambda的标准格式调用invokeCook方法，打印输出“吃饭啦！”字样

package com.itheima.demo04.Lambda;
/*
    定一个厨子Cook接口，内含 唯一的抽象方法makeFood
 */
public interface Cook {
    //定义无参数无返回值的方法makeFood
    public abstract void makeFood();
}

以上定义一个接口

package com.itheima.demo04.Lambda;
/*
    需求:
        给定一个厨子Cook接口，内含唯一的抽象方法makeFood，且无参数、无返回值。
        使用Lambda的标准格式调用invokeCook方法，打印输出“吃饭啦！”字样
 */
public class Demo01Cook {
    public static void main(String[] args) {
        //调用invokeCook方法,参数是Cook接口,传递Cook接口的匿名内部类对象
        invokeCook(new Cook() {       // 使用定义的方法
            @Override
            public void makeFood() {      //重写其中的抽象方法
                System.out.println("吃饭了");
            }
        });
        //使用Lambda表达式,简化匿名内部类的书写
        invokeCook(()->{
            System.out.println("吃饭了");
        });
        //优化省略Lambda
        invokeCook(()-> System.out.println("吃饭了"));
    }
    //定义一个方法,参数传递Cook接口,方法内部调用Cook接口中的方法makeFood
    public static void invokeCook(Cook cook){
        cook.makeFood();
    }
}

执行结果：

吃饭了
吃饭了
吃饭了

Process finished with exit code 0

Lambda表达式有参数有返回值的练习

需求: 使用数组存储多个Person对象 对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序

package com.itheima.demo05.Lambda;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;

public class Demo01Arrays {
    public static void main(String[] args) {
        //使用数组存储多个Person对象
        Person[] arr = {
                new Person("刘岩",38),
                new Person("迪丽热巴", 25),
                new Person("郭德纲",50)
        };
//        Arrays.sort(arr, new Comparator<Person>() {         // 升序（前边-后边）
//            @Override
//            public int compare(Person o1, Person o2) {
//                return o1.getAge()-o2.getAge();
//            }
//        });

        //使用lambda表达式
        Arrays.sort(arr, (Person o1, Person o2)->{
            return o1.getAge() - o2.getAge();
        });

        //遍历数组
        for (Person p : arr) {
            System.out.println(p);
        }
    }
}

注释中为普通方式，后面为lambda方式。

代码分析详见day07【线程池、Lambda表达式】-笔记.pdf

执行结果：

Person{name='迪丽热巴', age=25}
Person{name='刘岩', age=38}
Person{name='郭德纲', age=50}

Process finished with exit code 0

Lambda表达式有参数有返回值的练习(自定义接口)

给定一个计算器 Calculator 接口，内含抽象方法 calc 可以将两个int数字相加得到和值：

package com.itheima.demo06.Lambda;
/*
    给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值
 */
public interface Calculator {
    //定义一个计算两个int整数和的方法并返回结果
    public abstract int calc(int a, int b);    // 抽象方法
}

使用Lambda的标准格式调用invokeCalc方法，完成120和130的相加计算

package com.itheima.demo06.Lambda;

public class Demo01Calculator {
    public static void main(String[] args) {
        //调用invokeCalc方法,方法的参数是一个接口,可以使用匿名内部类
        invokeCalc(10, 20, new Calculator() {
            @Override
            public int calc(int a, int b) {      // 重写其中的方法
                return a+b;
            }
        });

        //使用Lambda表达式简化匿名内部类的书写
        invokeCalc(120,130,(int a,int b)->{
            return a + b;
        });

        //优化省略Lambda
        invokeCalc(120,120,(a,b)-> a + b);
    }
    /*
        定义一个方法
        参数传递两个int类型的整数
        参数传递Calculator接口
        方法内部调用Calculator中的方法calc计算两个整数的和
     */
    public static void invokeCalc(int a,int b,Calculator c){
        int sum = c.calc(a,b);
        System.out.println(sum);
    }
}

执行结果：

30
250
240

Process finished with exit code 0

 Lambda省略格式 

可推导即可省略 

可以省略的内容:
    1.(参数列表):括号中参数列表的数据类型,可以省略不写
    2.(参数列表):括号中的参数如果只有一个,那么类型和()都可以省略
    3.{一些代码}:如果{}中的代码只有一行,无论是否有返回值,都可以省略({},return,分号)
        注意:要省略{},return,分号必须一起省略

Lambda强调的是“做什么”而不是“怎么做”，所以凡是可以根据上下文推导得知的信息，都可以省略。例如上例还可 以使用Lambda的省略写法：

public static void main(String[] args) 
{    
    invokeCalc(120, 130, (a, b) ‐> a + b);    
}

举例（以上程序中体现）：

//使用Lambda表达式简化匿名内部类的书写
        invokeCalc(120,130,(int a,int b)->{
            return a + b;
        });

        //优化省略Lambda
        invokeCalc(120,120,(a,b)-> a + b);

Lambda的使用前提 

Lambda的语法非常简洁，完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意：

1. 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。

无论是JDK内置的 Runnable 、 Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一 时，才可以使用Lambda。

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

也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
备注：有且仅有一个抽象方法的接口，称为“函数式接口”。