使用Lambda的方式实现线程

线程中()是run方法的(),可用来接受参数，格式：

new Thread(()->{
            System.out.println(Thread.currentThread().getName() + "执行");
        },"Lambda线程创建").start();

Lambda标准格式：

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

Lambda表达式，是可推导，是可省略的

凡是可以根据上下文推导出来的内容，都可以省略不写
仅在接口只有一个抽象方法的时候，这种接口称为函数式接口
传递的方法或参数必须是Lambda对应接口类型，才能Lambda作为该接口实例

可以省略的内容：

(参数列表):括号中参数列表的数据类型可以省略不写
(参数列表):如果参数只有一个,类型和()都可以省略
{方法体}，如果代码只有一行，无论是否有返回值，{},return,分号都可以省略,必须一起省略
注：()里什么都没有不能省略

下面代码优化

//优化简写，省略了数据类型和{} return ；
Arrays.sort(person,(o1, o2) -> o1.getAge()-o2.getAge());


//优化简写,省略了{}和；
cookFood(() -> System.out.println("我最简单"));

练习一：

给定一个厨子接口，内含抽象方法，无参，无返回值

public interface Cook{
    public abstract void makeFood();
}

在main中打印输出接口抽象方法的实现

public class Demo01 {
    public static void main(String[] args) {
        //原型
        cookFood(new Cook() {
            @Override
            public void makeFood() {
                System.out.println("我太难了");
            }
        });

        //使用Lambda表达式
        cookFood(()->{
            System.out.println("我实现了接口方法");
        });

        //优化简写
        cookFood(() -> System.out.println("我最简单"));

    public static void cookFood(Cook cook){
        cook.makeFood();
    }
}

练习二：数组排序简化,Lambda表达式有参数

Person类

package cn.learn.thread.Lambda.practice;

public class Person {
    private String name;
    private int 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;
    }

    public Person() {
    }

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

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

数组排序

package cn.learn.thread.Lambda.practice;

import java.util.Arrays;
import java.util.Comparator;

public class Demo {
    public static void main(String[] args) {
        //使用数组存储Person对象
        Person[] person = {
                new Person("sda",12),
                new Person("sa",19),
                new Person("da",10)
        };

/*        //使用Arrays的sort方法进行排序，升序
        Arrays.sort(person, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge()-o2.getAge();
            }
        });*/

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

        //优化简写
        Arrays.sort(person,(o1, o2) -> o1.getAge()-o2.getAge());


        //增强for循环打印输出
        for (Person p:person) {
            System.out.println(p);
        }
    }
}

练习三：Lambda表达式求和

定义一个计算器接口

package cn.learn.thread.Lambda.practice;
public interface Calculator {
         public abstract int calc(int ...sum);
   }

实现运算

package cn.learn.thread.Lambda.practice;

public class Demo01 {
    public static void main(String[] args) {
        //使用匿名的方法求和
        //运行步骤：匿名创建实现类->实现类实现（重写）接口方法->传递匿名实现类->
        //->传递不定数量的数值->c.calc(sNum)调用接口方法计算值，并返回值给sum
        int sum = sumNumber(new Calculator() {
            int sum=0;
            //重写方法，无实参值运算
            @Override
            public int calc(int... num) {
                for (int n: num) {
                    sum+=n;
                }
                return sum;
            }
        },7,8,9);

        //使用Lambda表达式简写
        int sum01= sumNumber((int ...num)->{
            int temp=0;
            for (int n: num) {
                temp+=n;
            }
            return temp;
        },74,22);

        System.out.println(sum);//24
        System.out.println(sum01);//96
    }

    public static int sumNumber(Calculator c, int ...sNum){
        //把数组地址给接口方法的不定值num
        int sum = c.calc(sNum);
        return sum;
    }
}

接口

Lambda -语法使用，代码简化

使用Lambda的方式实现线程

Lambda标准格式：

Lambda表达式，是可推导，是可省略的

可以省略的内容：

练习一：

练习二：数组排序简化,Lambda表达式有参数

练习三：Lambda表达式求和