java1.8新特性Lambda表达式

体验Lambda表达式

package package28Lambda.Demo01;

/**
 * @Author:Fwh
 * @Description:
 * @Date:Creat in 22:26 2021/10/14
 * @Modified By:
 */
/*
* 使用Lambda表达式实现多线程
* */
public class Demo01Lambda {
    public static void main(String[] args) {
        //使用匿名内部类，实现多线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"新线程创建了");
            }
        }).start();
        //使用Lambda表达式实现多线程
        new Thread(()-> {
            System.out.println(Thread.currentThread().getName() + "新线程创建了");
        }
        ).start();
    }
}

使用匿名内部类的好处和弊端

一方面，匿名内部类可以帮我们省去实现类的定义；另一方面，匿名内部类的语法–确实太复杂了

Lambda表达式的分析：

匿名内部类当中：

Runable接口当中只有一个run方法的定义

• public abstract void run();

即制定了做事情的方案。

• 无参数：不需要任何条件即可执行的方案
• 无返回值：该方案不产生任何结果
• 代码块（方法体）：该方案的具体执行步骤

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

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

• 前面的 ()表示即run方法的参数(无)，代表不需要任何条件
• 中间的箭头带白哦将前面的参数传递给后面的代码
• 后面的输出语句即业务逻辑代码

1.Lambda标准格式

由三部分组成：

• 一些参数
• 一个箭头
• 一段代码

Lambda表达式的标准格式为：

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

2.练习：使用Lambda标准格式（无参无返回）

package package28Lambda.Demo02;

/**
 * @Author:Fwh
 * @Description:
 * @Date:Creat in 22:50 2021/10/14
 * @Modified By:
 */
public interface Cook {
    //定义无参数无返回的方法makeFood
    public abstract void makeFood();
}

package package28Lambda.Demo02;

/**
 * @Author:Fwh
 * @Description:
 * @Date:Creat in 22:51 2021/10/14
 * @Modified By:
 */
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("开饭了");
        });
    }

    //定义一个方法，参数传递Cook接口，方法内部调用Cook接口中的方法makeFood
    public static void invokeCook(Cook cook){
        cook.makeFood();
    }
}

3.练习：使用Lambda标准格式（有参有返回）

package package28Lambda.Demo03;

/**
 * @Author:Fwh
 * @Description:
 * @Date:Creat in 22:57 2021/10/14
 * @Modified By:
 */
public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package package28Lambda.Demo03;

import java.util.Arrays;

/**
 * @Author:Fwh
 * @Description:
 * @Date:Creat in 22:58 2021/10/14
 * @Modified By:
 */
public class Demo01Arrays {
    public static void main(String[] args) {
        //创建数组存储多个Person对象
        Person[] arr = {
                new Person("小明",38),
                new Person("小红",18),
                new Person("小刚",19),
        };
        //对数组中的Person对象使用Arrays的sort方法通过年龄进行升序（前边-后边）排序
        /*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 person : arr) {
            System.out.println(person);
        }
    }
}

4.Lambda表达式的省略格式

Lambda 表达式：是可推倒，可省略

凡是根据上下文推倒出来的内容，都可以省略书写

可以省略的内容：

1.(参数列表)：**括号中的参数列表的数据类型，**可以省略不写

2.(参数列表)：括号中的参数如果只有一个，那么**类型和()**都可以不写

3.(一些代码)：如果大括号中的代码只有一行，无论是否有返回值，都可以省略（{},return,;）要省略三种必须一起省略

//使用Lambda表达式实现多线程
new Thread(()-> {
    System.out.println(Thread.currentThread().getName() + "新线程创建了！！");
}
).start();

//优化Lambda表达式
new Thread(() -> System.out.println(Thread.currentThread().getName()+"新线程创建了！！！")).start();

//使用Lambda表达式，简化匿名内部类的书写
invokeCook(() -> {
    System.out.println("开饭了");
});
//优化Lambda表达式
invokeCook(() -> System.out.println("开饭喽"));

//使用Lambda表达式简化匿名内部类
Arrays.sort(arr,(Person o1,Person o2) ->{
    return o1.getAge()-o2.getAge();
});
//优化Lambda表达式
Arrays.sort(arr,(o1,o2)->o1.getAge()-o2.getAge());

package package28Lambda.Demo04Lambda;

import java.util.ArrayList;

/**
 * @Author:Fwh
 * @Description:
 * @Date:Creat in 23:11 2021/10/14
 * @Modified By:
 */
/*
* Lambda 表达式：是可推倒，可省略
* 凡是根据上下文推倒出来的内容，都可以省略书写
* 可以省略的内容：
*   1.(参数列表)：括号中的参数列表的数据类型，可以省略不写
*   2.(参数列表)：括号中的参数如果只有一个额，那么类型和()都可以不写
*   3.(一些代码)：如果大括号中的代码只有一行，无论是否有返回值，都可以省略（{},return,;）
*       要省略三种必须一起省略
* */
public class Demo01ArrayList {
    public static void main(String[] args) {
        //jdk1.7之前，创建集合对象必须把前后的泛型都写上
        ArrayList<String> list01 = new ArrayList<String>();
        //jdk1.7之后，=后面的泛型可以省略，后面的泛型可以根据前面的泛型推导出来
        ArrayList<String> list02 = new ArrayList<>();
    }
}

5.使用Lambda表达式的前提

使用Lambda表达式前提

1. 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法
2. 使用Lambda必须具有上下文推断：也就是方法的参数或局部变量必须是Lambda对应的接口类型，才能使用Lambda作为接口的实例

备注：有且只有一个抽象方法的接口，成为“函数式接口”