Java中的Lambda表达式

Lambda 表达式是使用最小可能语法编写的函数定义：

• Lambda 表达式产生函数，而不是类。 虽然在 JVM（Java Virtual Machine，Java 虚拟机）上，一切都是类，但是幕后有各种操作执行让 Lambda 看起来像函数 —— 作为程序员，你可以高兴地假装它们“就是函数”。

• Lambda 语法尽可能少，这正是为了使 Lambda 易于编写和使用。

函数式接口

任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口
对于函数式接口，我们可以通过lambda表达式来创建该接口的对象
注意： 函数式接口可包含默认的方法

// 1. 定义一个函数式接口interfaceILike{voidlambda();defaultpublicvoidprint(){
        System.out.println("hah");}}

lambda 演变过程

publicclassLambdaTest{publicstaticvoidmain(String[] args){
        ILike like=newLike();
        like.lambda();

        like=newLike2();
        like.lambda();// 4. 局部内部类classLike3implementsILike{@Overridepublicvoidlambda(){
                System.out.println("i like lambda3");}}
        like=newLike3();
        like.lambda();// 5. 匿名内部类，没有类的名称，必须借助接口或者父类
        like=newILike(){@Overridepublicvoidlambda(){
                System.out.println("i like lambda4");}};
        like.lambda();// 6. 用lambda简化
        like=()->{
            System.out.println("i like lambda5");};
        like.lambda();}}// 2. 实现类classLikeimplementsILike{@Overridepublicvoidlambda(){
        System.out.println("i like lambda");}}

lambda表达式特征

• 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
• 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
• 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
• 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

案例

//单个参数
like=(words)->{
    System.out.println("i like "+ words);};
like.lambda("lambda");//多个参数
like=(String words,int year)->{
    System.out.println("i like "+ words);
    System.out.println("this year is "+ year);};
like.lambda("lambda",2021);

方法引用

1. 对象::实例方法，将lambda的参数当作方法的参数使用

/**
 *print(String x)的签名(参数类型和返回类型)符合ILike的lambda(String worlds)签名
 */
ILike like= System.out::print;//等效
ILike like=(x)->System.out.print(x);

2. 类::静态方法，将lambda的参数当做方法的参数使用

//ClassName::staticMethod  类的静态方法：把表达式的参数值作为staticMethod方法的参数
Function<Integer, String> sf= String::valueOf;//等效
Function<Integer, String> sf2=(x)-> String.valueOf(x);
String apply= sf.apply(61888);//Function接口，接受两个类型为T,R的参数, 调用apply(T t)方法，返回T类型的结果。@FunctionalInterfacepublicinterfaceFunction<T, R>{/**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    Rapply(T t);...}

3. 类::实例方法，将lambda的第一个参数当做方法的调用者，其他的参数作为方法的参数。

//ClassName::instanceMethod  类的实例方法：把表达式的第一个参数当成instanceMethod的调用者，其他参数作为该方法的参数
BiPredicate<String, String> sbp= String::equals;//等效
BiPredicate<String, String> sbp2=(x, y)-> x.equals(y);boolean test= sbp.test("a","A");@FunctionalInterfacepublicinterfaceBiPredicate<T, U>{/**
     * Evaluates this predicate on the given arguments.
     *
     * @param t the first input argument
     * @param u the second input argument
     * @return {@code true} if the input arguments match the predicate,
     * otherwise {@code false}
     */booleantest(T t, U u);...}

构造函数

无参的构造方法，类::实例方法模型。

Supplier<User> us= User::new;//等效
Supplier<User> us2=()->newUser();//获取对象
User user= us.get();@FunctionalInterfacepublicinterfaceSupplier<T>{/**
     * Gets a result.
     * @return a result
     */
    Tget();}

有参构造函数

//一个参数,参数类型不同则会编译出错
Function<Integer, User> uf= id->newUser(id);//或加括号
Function<Integer, User> uf2=(id)->newUser(id);//等效
Function<Integer, User> uf3=(Integer id)->newUser(id);
User apply= uf.apply(1002);//两个参数
BiFunction<Integer, String, User> ubf=(id, name)->newUser(id, name);
User 狂欢happy= ubf.apply(1001,"lucy");

Java 8 引入了 java.util.function 包。它包含一组接口，这些接口是 Lambda 表达式和方法引用的目标类型。 每个接口只包含一个抽象方法，称为 函数式方法 。