lambda函数式接口使用体会

嘚不嘚：刚开始用起来确实很不习惯，不过用起来确实很方便，用了好久才会用的，刚开始的时只是简单的会用，用的还不是很6，虽然现在也不6但是知道lambda表达式是如何转换的。

概述

1. lambda表达式形式：（） -> expression
2. 意义：在java8之前，java方法的调用是通过对象调用的，在jdk1.8之后方法的调用可以通过表达式了，a.b（c）对象a，调用b方法，参数为c，c是一个对象，java8之后方法的调用方式a.b(expression)，注意这里的expresstion并不是一个简单方法的调用，a.b(a.c())方法的调用形式，而是一种行为，下面就说说这是一个什么行为。
3. 行为：java8以前表示行为的方式是通过匿名内部类表示的，是不是好眼熟，对匿名内部类就是行为的表示方式 ，匿名内部类由其他的实现方式转换过来的。

   	 /**
        * 行为表达方式
        */
       new Thread(new Runnable() {
           @Override
           public void run() {       
           }
       });
     	 /**
        * RunImpl 实现了Runnable接口
        */
       new Thread(new RunImpl());
   

4. 什么样的接口可以行为传递呢：只定义了唯一抽象方法的接口实现lambda表达式，被称为函数式接口。我们可以自定义函数接口，也可以是使用jdk给我们提供的接口：

• [ java.util.function.Predicate ] ：boolean test(T t) 入参T，返回结果为boolean。
• [ java.util.function.Consumer ] ：void accept(T t); 入参T，无法回结果，可以进行输出和其他的方法调用，
• [ java.util.function.Function ] ：R apply(T t); 入参T，返回结果类型为R。
• [ java.util.function.Supplier ] ：T get(); 无入参，返回结果为T。

5. lambda表达式和匿名内部类相比较：性能开销：如果lambda表达式是通过使用匿名类来实现的，那么每一个lambda表达式都要在磁盘上产生一个文件。如果这些类在JVM启动时被加载，那么JVM的启动时间将会增加，因为所有的类在使用前都要进行加载和验证。

BiFunction

1. 概述：直接看代码，代码展示了lambda表达式到底是怎么样玩的。我现在要做的很简单就是使用BiFunction这个接口完成"a"，“b” -> “ab”，我相信看这文章的人都知道我要做字符串连接。
2. BiFunction的接口定义：

public interface BiFunction<T, U, R> {
    /**
     * Applies this function to the given arguments.
     *
     * @param t the first function argument
     * @param u the second function argument
     * @return the function result
     */
    R apply(T t, U u);

参数说明：T，U为泛型入参，R为该方法的返回结果类型，T、U、R的类型在java文件编译时就可以确定。

3. 方法定义：就是要完成对该方法的调用

  /**
     *  函数式表达式的接口定义其目的就是实现传参时的行为， 次方法参数的行为就是a.concat(b)
     * @param a
     * @param b
     * @param biFunction
     * @return
     */
    public static String getStr(String a,String b,BiFunction<String,String,String> biFunction){
        return biFunction.apply(a,b);
    }

4. 实现BiFunction接口的方式对getStr方法调用

public class BiFuntionImpl<T, U, R> implements BiFunction<T, U, R>{
    @Override
    public R apply(T t, U u) {
        String s1 = (String)t;
        String s2 = (String)u;
        return (R)s1.concat(s2);
    }
		 /**
         * 方法调用
         */
      System.out.println(getStr("x","y",new BiFuntionImpl<>()));
}

在实现类的方法中完成想要对方法的操作
5. 匿名内部类方式调用：

 getStr("x", "y", new BiFunction<String, String, String>() {
            @Override
            public String apply(String s, String s2) {
                return s.concat(s2);
            }
        });

6. lambda方式调用：

getStr("x","y",(a,b) -> a.concat(b));

（a,b）为BiFunction接口中apply方法的入参，但是好像并没有定义参数（a,b）的类型。lambda表达式的类型是根据上下文确定的，该类型是在编译时就确定的。

—>操作符号，将参数和表达式分开。

a.concat(b) 是apply方法的实现。表达式可以是函数的调用，也可以是函数的输出。

参考博客1