Lambda 表达式

1. 什么是 Lambda？

Lambda 是 Java8 增加的新个性，说白了，Lambda 是一个一名函数 

2.Lambda 根底语法

Lambda 是一个匿名函数 个别关注一下两个重点
1. 参数列表
2. 办法体

(): 用来形容参数列表
{}: 用来形容办法体
->:Lambda 运算符 读作 goes to

/**
 * 无参数无返回值接口
 */
@FunctionalInterface
public interface LambdaNoneReturnNoneParmeter {void test();
}

/**
 * 无返回值有单个参数
 */
@FunctionalInterface
public interface LambdaNoneReturnSingleParmeter {void test(int n);
}

/**
 * 无返回值 多个参数的接口
 */
@FunctionalInterface
public interface LambdaNoneReturnMutipleParmeter {void test(int a,int b);
}

/**
 * 有返回值 无参数接口
 */
@FunctionalInterface
public interface LambdaSingleReturnNoneParmeter {int test();
}

/**
 * 有返回值 有单个参数的接口
 */
@FunctionalInterface
public interface LambdaSingleReturnSingleParmeter {int test(int n);
}

/**
 * 有返回值 有多个参数的接口
 */
@FunctionalInterface
public interface LambdaSingleReturnMutipleParmeter {int test(int a,int b);
}

/**
 * @author Alan
 */
public class Syntax1 {public static void main(String[] args) {
        // 1.Lambda 表达式的根底语法
        // Lambda 是一个匿名函数 个别关注的是以下两个重点
        // 参数列表 办法体

        /**
         *（）：用来形容参数列表
         *  {}：用来形容办法体
         *  ->: Lambda 运算符 读作 goes to
         */

        // 无参无返回  
        LambdaNoneReturnNoneParmeter lambda1=()->{System.out.println("hello word");
        };
        lambda1.test();

        // 无返回值 单个参数 
        LambdaNoneReturnSingleParmeter lambda2=(int n)->{System.out.println("参数是："+n);
        };
        lambda2.test(10);

        // 无返回值 多个参数
        LambdaNoneReturnMutipleParmeter lambda3=(int a,int b)->{System.out.println("参数和是："+(a+b));
        };
        lambda3.test(10,12);

        // 有返回值 无参数
        LambdaSingleReturnNoneParmeter lambda4=()->{System.out.println("lambda4：");
            return 100;
        };
        int ret=lambda4.test();
        System.out.println("返回值是："+ret);

        // 有返回值 单个参数
        LambdaSingleReturnSingleParmeter lambda5=(int a)->{return a*2;};
        int ret2= lambda5.test(3);
        System.out.println("单个参数，lambda5 返回值是:"+ret2);

        // 有返回值 多个参数
        LambdaSingleReturnMutipleParmeter lambda6=(int a,int b)->{return a+b;};
        int ret3=lambda6.test(12,14);
        System.out.println("多个参数，lambda6 返回值是："+ret3);
    }
}

输入后果：hello word
    参数是：10
    参数和是：22
    lambda4：返回值是：100
    单个参数，lambda5 返回值是:6
  多个参数，lambda6 返回值是：26

3. 语法精简

3.1. 参数类型精简

/**
* 语法精简
* 1. 参数类型
* 因为在接口的形象办法中，曾经定义了参数的数量类型 所以在 Lambda 表达式中参数的类型能够省略
* 备注：如果须要省略类型，则每一个参数的类型都要省略，千万不要一个省略一个不省略
*/
LambdaNoneReturnMutipleParmeter lambda1=(int a,int b)-> {System.out.println("hello world"); 
};    
能够精简为:
LambdaNoneReturnMutipleParmeter lambda1=(a,b)-> {System.out.println("hello world");
};

3.2. 参数小括号精简

/**
* 2. 参数小括号
* 如果参数列表中，参数的数量只有一个 此时小括号能够省略
*/
LambdaNoneReturnSingleParmeter lambda2=(a)->{System.out.println("hello world");
};
能够精简为:
LambdaNoneReturnSingleParmeter lambda2= a->{System.out.println("hello world");
};

3.3. 办法大括号精简

/**
* 3. 办法大括号
* 如果办法体中只有一条语句，此时大括号能够省略
*/
LambdaNoneReturnSingleParmeter lambda3=a->{System.out.println("hello world");
};
能够精简为:
LambdaNoneReturnSingleParmeter lambda3=a->System.out.println("hello world");

3.4. 大括号精简补充

/**
* 4. 如果办法体中惟一的一条语句是一个返回语句
* 省略大括号的同时 也必须省略 return
*/
LambdaSingleReturnNoneParmeter lambda4=()->{return 10;};
能够精简为:
LambdaSingleReturnNoneParmeter lambda4=()->10;

3.5. 多参数，有返回值 精简

LambdaSingleReturnNoneParmeter lambda4=(a,b)->{return a+b;};
能够精简为:
LambdaSingleReturnMutipleParmeter lambda5=(a,b)->a+b;

4.Lambda 语法进阶

public class Syntax3 {public static void main(String[] args) {
        
        LambdaSingleReturnSingleParmeter lambda1=a->a*2;
        LambdaSingleReturnSingleParmeter lambda2=a->a*2;
        LambdaSingleReturnSingleParmeter lambda3=a->a*2;

        // 简化
        LambdaSingleReturnSingleParmeter lambda4=a->change(a);

        // 办法援用
        LambdaSingleReturnSingleParmeter lambda5=Syntax3::change;
    }

    /**
    * 自定义的实现办法
    */
    private static int change(int a){return a*2;}
}