创建多线程之Lambda表达式

Lambda表达式的标准格式

1.一些参数
2.一个箭头
3.方法体

标准格式为：(参数类型  参数名称)->{线程要实现的具体的任务 }

格式说明：

• 小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。
• -> 是新引入的语法格式，代表指向动作
• 大括号内的语法与传统方法体要求基本一致。

练习一：使用Lambda标准格式（无参无返回）
给定一个厨子 Cook 接口，内含唯一的抽象方法 makeFood ，且无参数、无返回值。如下：

//Cook接口
public interface Cook {
    abstract void makeFood();
}

/**
 * 给定一个厨子 Cook 接口，内含唯一的抽象方法 makeFood ，且无参数、无返回值。xxxxxxxxxxxxxx
 */
public class Test {
    public static void main(String[] args) {
        //匿名内部类:调用invokeFood方法，传递接口Cook的匿名内部类对象
        invokeFood(new Cook() {
            @Override
            public void makeFood() {
                System.out.println("吃饭了");
            }
        });
        invokeFood(()->{
            System.out.println("吃饭了");
        });
    }
    //定义一个方法invokeFood，参数传递Cook接口，方法内部调用makeFood方法
    private static void invokeFood(Cook cook){
        cook.makeFood();
    }
}

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

Person类

public class Person {
    private String name;
    private int age;

    public Person() {
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

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

测试类

/**
 * 需求：使用数组创建多个对象，对多个对象的年龄使用Arrays的sort()进行升序排序。
 */
public class Lamb {
    public static void main(String[] args) {
        Person[] arry = {
                new Person("张三",19),
                new Person("李四",30),
                new Person("王五",58),
        };
       /* //使用匿名内部类的方式
        Arrays.sort(arry, new Comparator<Person>() {
            //升序前面一个减去后面一个
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge()- o2.getAge();
            }
        });*/
        //使用lamb表达式的方式
        Arrays.sort(arry,(Person o1, Person o2)->{
            return o1.getAge()- o2.getAge();
        });
        for (Person person : arry) {
            System.out.println(person);
        }
    }
}

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

Caculator接口

/**
 需求：给定一个计算器Caculator接口，内含抽象方法cal()计算两个int类型的整数的和，使用lambda表达式的调用invokeCalc方法计算两个整数的和
*/
public interface Caculator {
  public abstract int cal(int a,int b);
}

测试类

public class Test {
    public static void main(String[] args) {
        //匿名内部类的方式
        invokeCalc(10, 20, new Caculator() {
            @Override
            public int cal(int a, int b) {
                return a+b;
            }
        });
        //使用lambda表达式(参数类型)->{ 方法体 }
        invokeCalc(120,130,( int a, int b)->{
            return a+b;
        });
    }
    public static void invokeCalc(int a,int b,Caculator c){
        int sum = c.cal(a,b);
        System.out.println(sum);
    }
}

注意：
lambda表达式的使用前提：
1.使用lambda表达式必须有接口，接口中有且仅有一个抽象方法。
2.使用lambda表达式必须有上下文的推断。

备注：有且仅有以一个抽象方法的接口称为函数式接口。