今天是裸辞整整2周，感觉慢慢开始习惯了，没有短信轰炸，没有企业微信推送，没有代办事项...

JDK1.8对应的新特性比较多了，主要有lambda表达式支持、方法引用、Stream API以及JVM内存模型的一些调整。这里主要学习一下lambda 以及方法引用。

Lambda

Lambda 表达式就像三元表达式一样，是一种连贯的将逻辑进行表达的方式，Lambda的语法建立在函数式接口 FunctionInterface 的基础上，书写Lambda表达式时我们需要先定一个函数式接口interface，然后对interface的抽象方法使用Lambda表达式进行实现。

    @FunctionalInterface
    interface LambdaTest {
        void test();
    }

    public static void main(String[] args) {
        LambdaTest lambdaTest = ()-> System.out.println("empty method");
        lambdaTest.test();
    }

刚开始接触Lambda看到上面的第一感觉是有点懵逼的，表达式中没有出现test()方法的实现关键字，这就是Lambda的魔力所在，感觉参数自动映射到对应的方法，不过魔力也只是表象，真正的原因是FunctionalInterface 定义的接口只能有且只有一个待实现的抽象方法，那不映射它还能映射谁呢，所以直接省略掉名字。

这也是我看springboot源码有关ApplicationContextFactory接口时没有反映过来，拼命到处找抽象方法create的实现无果的原因，后面会引用这个来说明下Lambda在springboot 源码中的应用。

Lambda 语法

(parameters) -> expression
或
(parameters) ->{ statements; }

括号内的parameters 和FunctionalInterface中定义的方法一样，空、单个参数、多个参数都可以，expression 标示单个逻辑实现，单行单句的情况，如果是多行多句就需要使用{}括号起来。
【注意】expresion语句即使有返回值，也可以省略return 关键字
下面列举的是几个参数以及返回值接口定义及其Lambda表达式实现的

    //带一个参数
    @FunctionalInterface
    interface LambdaTest2 {
        void test(String s);
    }
    public static void main(String[] args) {
        LambdaTest2 lambdaTest2 = (x)-> System.out.println(x);
        lambdaTest2.test("abc");
    }
    //输出：abc

   
    //带2个参数
    @FunctionalInterface
    interface LambdaTest3 {
        void test(String s,String a);
    }
    public static void main(String[] args) {
        LambdaTest3 lambdaTest3 = (x,y) -> System.out.println(x+y);
        lambdaTest3.test("x","y");
    }
    //输出：xy

    //带2个参数，1个返回值
    @FunctionalInterface
    interface LambdaTest4 {
        String test(String s,String a);
    }
    public static void main(String[] args) {
        LambdaTest4 lambdaTest4 = (x,y) -> x+"_"+y;
        System.out.println(lambdaTest4.test("a","b"));
    }
    //输出：a_b

Lambda在springboot SpringApplication.class 中的应用

相信你也有去了解过SpringApplication.run方法里面都执行了什么操作，如果没有看过，可以花点时间了解下，还是可以学习到不少东西，更好的使用springboot

在SpringApplication（springboot 2.4.5）构造方法是下面这样

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        this.sources = new LinkedHashSet();
        this.bannerMode = Mode.CONSOLE;
        this.logStartupInfo = true;
        this.addCommandLineProperties = true;
        this.addConversionService = true;
        this.headless = true;
        this.registerShutdownHook = true;
        this.additionalProfiles = Collections.emptySet();
        this.isCustomEnvironment = false;
        this.lazyInitialization = false;
        this.applicationContextFactory = ApplicationContextFactory.DEFAULT;
        this.applicationStartup = ApplicationStartup.DEFAULT;
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
        this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        this.bootstrapRegistryInitializers = this.getBootstrapRegistryInitializersFromSpringFactories();
        this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
        this.mainApplicationClass = this.deduceMainApplicationClass();
    }

其中下面这2行代码是我们要说明的重点

//springboot会根据加载的类来判断当前是什么类型的项目，    NONE,SERVLET,REACTIVE 三者中之一
this.webApplicationType = WebApplicationType.deduceFromClasspath();
//这里就是引用了一个Lambda表达式
//这个表达式的内容写在了对应的函数式接口中而已
this.applicationContextFactory = ApplicationContextFactory.DEFAULT;

对应的函数式接口ApplicationContextFactory代码如下：

@FunctionalInterface
public interface ApplicationContextFactory {
    ApplicationContextFactory DEFAULT = (webApplicationType) -> {
        try {
            switch(webApplicationType) {
            case SERVLET:
                return new AnnotationConfigServletWebServerApplicationContext();
            case REACTIVE:
                return new AnnotationConfigReactiveWebServerApplicationContext();
            default:
                return new AnnotationConfigApplicationContext();
            }
        } catch (Exception var2) {
            throw new IllegalStateException("Unable create a default ApplicationContext instance, you may need a custom ApplicationContextFactory", var2);
        }
    };

    ConfigurableApplicationContext create(WebApplicationType webApplicationType);
}

上面DEFAULT 这里是一个LAMBDA表达式，实现的是下面 create方法，返回的是一个ConfigurableApplicationContext 实现类。

上面提到的我到处去找create方法的实现，没想到实现就在上面，“众里寻他千百度，蓦然回首，那人却在，灯火阑珊处”。

方法引用

第一眼看到java代码中如下面样式的代码的时候，还以为这个应该不是java代码吧，应该是C#之类的。

 NameInterface nameInterface = Person::getName

上面这个就是JDK1.8新特性：方法引用。
定义：方法引用通过方法的名字来指向一个方法，可以使语言的构造更紧凑简洁，减少冗余代码。
作用：当我们定义了一个接口抽象方法，然后发现其他地方有你想要的实现逻辑方法，那就不用再费力去写一个，即使这个实现方法和当前模块没有任何关系，引用过来用就是了。这就是方法引用，将某一目标方法代码复制过来使用。

下面是一个列子：

@FunctionalInterface
interface MethodTest{
    void print(String name);
}
//和MethodTest没有任何关系的类一个
class Person2{
    private String name;

    public Person2(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void print(String name){
        System.out.println("name="+name);
    }
}

public static void main(String[] args) {
        MethodTest methodTest = new Person2("abc")::print;
        methodTest.print("method test print");
    }

//输出：name=method test print

就是这么神奇。上面MethodTest定义的抽象方法名字同Person中国呢定义的方法print并不一定要相同名字，只要返回参数以及输入参数等签名一致即可。

说在最后

Lambda 的作用，将实现函数逻辑部分的代码，用表达式的形式定义到一个变量中，然后将变量作为方法入参传到方法中。
方法引用的作用：复用其他代码，减少冗余代码。