Lambda表达式

实现Runnable接口方式实现多线程程序
创建Runnable接口实现类，重写run方法，设置线程任务

public class RunnableImpl implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"新的线程创建");
    }
}

public class demoRunnable {
    public static void main(String[] args) {
        RunnableImpl run=new RunnableImpl();//创建Runnable实现类对象
        Thread th=new Thread(run);//创建Thread类对象，构造方法中传递Runnable接口的实现类
        th.start();//调用start方法开启新的线程，执行run方法
        Runnable r=new RunnableImpl(){//简化代码块
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"又一个新线程实现");
            }
        };
        new Thread(r).start();
        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表达式语义分析

仔细分析该代码中的语义，Runnable接口只有一个run方法的定义：
public abstract void run（）;
即定制了一种做事方案（实际就是一个函数）：
1、无参数：不需要任何条件即可执行这个方案
2、无返回值：该方案不产生任何结果
3、代码块（方法体）：该方案的具体执行步骤
（)->System.out.println(“多线程任务”);
前一对小括号即run方法的参数（无），代表不需要任何条件；
中间的一个箭头代表将前面的参数传递给后面的代码；
后面的输出语句即业务逻辑代码
格式是(参数列表)->{一些重写方法的代码}
解释说明：
（）：接口中抽象方法的参数列表，没有参数就空着，有参数就写出参数，多个参数使用逗号分隔
->:传递的意思，把参数传递给方法体{}
{}：重写接口的抽象方法

Lambda无参练习

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

需求：给定一个Cook接口，内含有唯一的抽象方法makeFood，且无参数，无返回值

• 使用Lambda的标准格式调用invokeCook方法，打印出"吃饭啦！字样"*/

public class demoCook {
    public static void main(String[] args) {
        invokeCook(new Cook() {
            @Override
            public void makeCook() {
                System.out.println("吃饭啦！");
            }
        });
        invokeCook(()->{
            System.out.println("吃饭啦！！！");
        });
    }
    public static void invokeCook(Cook cook){//定义一个方法，参数传递Cook接口，方法内部调用Cook接口中的方法makeFood
        cook.makeCook();
    }
}

Lambda有参使用方法

Lambda表达式有参数有返回值的练习
需求：使用数组存储多个Person对象
对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排列

import java.util.Arrays;
import java.util.Comparator;
public class demoArrays {
    public static void main(String[] args) {
        Person[] arr={
          new Person("柳岩",38),
                new Person("迪丽热巴",18),
                new Person("古力娜扎",19)
        };
        Arrays.sort(arr, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge()-o2.getAge();
            }
        });
        for (Person p:arr){
            System.out.println(p);
        }
        System.out.println("++++++++++");
        Arrays.sort(arr,(Person o1,Person o2)->{
            return o1.getAge()- o2.getAge();
        });
        for (Person p:arr){
            System.out.println(p);
        }
    }
}

创建一个Person类

```java
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;
    }
}

Lambda有参数有返回值

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

public interface Calculator {
    public abstract int calc(int a,int b);
}

Lambda表达式有一个参数有返回值的练习
需求：给定一个计算器Calculator接口，内含有抽象方法calc可以将两个int数字相加得到和值
使用Lambda的标准格式调用invokeCalc方法完成120和130的相加计算

public class demoCalculator {
    public static void main(String[] args) {
        invokeCalc(10, 20, new Calculator() {
            @Override
            public int calc(int a, int b) {
                return a+b;
            }
        });
        invokeCalc(20,30,(int a,int b)->{
            return 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);
    }
}

Lambda表达式可省略的部分

Lambda表达式：是可以推导可以省略的，凡是根据上下文推到出来的内容都可以省略书写
可以省略的内容：1、（参数列表）：括号中参数列表的数据类型可以省略不写
2、（参数列表）：括号中参数如果只有一个，那么类型和（）都可以不用写
3、{一些代码}：如果{}中的代码只有一行，无论是否有返回值都可以省略（{},return,分号）
注意：要省略{}，return，分号必须一起省略

invokeCalc(20,30,( a, b)-> a+b);

对比

  invokeCalc(20,30,(int a,int b)->{
            return a+b;
        });