Lambda表达式

package com.fgy.demo08;

/**
 *  使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法
 *  使用Lambda必须具有上下文推断
 *  　　也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例
 *  有且仅有一个抽象方法的接口，称为“函数式接口”
 */
public class LambdaTest {
    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();


    }
}

package com.fgy.demo08;

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



package com.fgy.demo08;

/**
 * Lambda表达式：是可推导，可以省略的
 * 凡是可以根据上下文推导出的内容都可省略
 * 可以省略的内容：
 *         1.(参数列表)：括号中的参数类型可以省略
 *         2.(参数列表)：如果参数只要一个，那么括号和参数类型都可以省略
 *         3.{一些代码}：如果{}中只有一行代码，无论是否有返回值，{}、return和分号都可以省略
 *              注意：{}、return和分号必须一起省略
 */
public class CookTest {
    public static void main(String[] args) {
        /*invokeCook(() -> {
            System.out.println("吃饭了");
        });*/

        invokeCook(() -> System.out.println("吃饭了"));
    }

    private static void invokeCook(Cook cook) {
        cook.makeCook();
    }
}

package com.fgy.demo08;

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

    public Person() {
    }

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

    public Integer getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

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



package com.fgy.demo08;

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

public class PersonTest {
    public static void main(String[] args) {
        Person[] persons = {
                new Person("lily", 28),
                new Person("sily", 19),
                new Person("jomn", 25),
        };

        /*Arrays.sort(persons, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() - o2.getAge();
            }
        });*/

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

        // Lambda表达式省略格式
        Arrays.sort(persons, (o1, o2) -> o1.getAge() - o2.getAge());

        for (Person person : persons) {
            System.out.println(person);
        }
    }
}