数据结构：lambda表达式

数据结构：lambda表达式

引用

CSDN

1.

https://blog.csdn.net/zm3rttqs9f/article/details/145966560

1、背景

Lambda表达式是JavaSE8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接 口。lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(可以是一个表达式或一个代码块)。Lambda表达式，基于数学中的 λ 演算得名，也可称为闭包。

2、语法

基本语法:(parameters)->expression或(parameters)->{statements;}

1. paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。
2. -> ：可理解为“被用于”的意思 。
3. 方法体：可以是表达式也可以代码块，是函数式接口里方法的实现。

代码块可返回一个值或者什么都不返回，这里的代码块块等同于方法的方法体。

如果是表达式，也可以返回一个值或者什么都不返回。

// 2. 接收⼀个参数(数字类型),返回其2倍的值 // 5. 接受⼀个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s);

3、函数接口

我们的Lambda表达式于函数接口息息相关，因此我们需要对函数接口进行了解。

函数式接口定义：一个接口有且只有一个抽象方法。

注意：

1. 如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口。
2. 如果我们在某个接口上声明了 @FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求该接口，这样如果有 两个抽象方法，程序编译就会报错的。所以，从某种意义上来 说，只要你保证你的接口中只有一个抽象方法，你可以不加这个注解。加上就会自动进行检测的。

定义方式：

interface NoParameterNoReturn {

这种方式的定义也是可以的

interface NoParameterNoReturn {
    System.out.println("JDK1.8新特性，default默认⽅法可以有具体的实现");

4、Lambda表达式的基本使用

语法精简

1. 参数类型可以省略，如果需要省略，每个参数的类型都要省略。
2. 参数的小括号里面只有一个参数，那么小括号可以省略
3. 如果方法体当中只有一句代码，那么大括号可以省略
4. 如果方法体中只有一条语句，且是return语句，那么大括号可以省略，且去掉return关键字。

我们事先准备好几个接口：

interface NoParameterNoReturn {
interface OneParameterNoReturn {
interface MoreParameterNoReturn {
interface NoParameterReturn {
interface OneParameterReturn {
interface MoreParameterReturn {

我们在上面提到过，Lambda可以理解为：Lambda就是匿名内部类的简化，实际上是创建了一个类，实现了接口，重写了接口的方法。

因此这就是我们不用lambda表达式的调用方法

NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn(){
    System.out.println("hello");
noParameterNoReturn.test();

（1）无返回值无参数

interface NoParameterNoReturn {
public static void main(String[] args) {
    NoParameterNoReturn noParameterNoReturn = ()-> System.out.println("⽆参数⽆返回值 ");
    noParameterNoReturn.test();

（2）无返回值一个参数

interface OneParameterNoReturn {
public static void main(String[] args) {
    OneParameterNoReturn oneParameterNoReturn = a-> System.out.println("⼀个参数⽆返回值： "+ a);
    oneParameterNoReturn.test(10);

（3）无返回值多个参数

interface MoreParameterNoReturn {
public static void main(String[] args) {
    MoreParameterNoReturn moreParameterNoReturn = (a, b)-> System.out.println(" 多个参数⽆返回值： "+a+" "+b);
    moreParameterNoReturn.test(20,30);

（4）有返回值无参数

interface NoParameterReturn {
public static void main(String[] args) {
    NoParameterReturn noParameterReturn = ()-> 40;
    int ret = noParameterNoReturn.test();

（5）有返回值一个参数

interface OneParameterReturn {
public static void main(String[] args) {
    OneParameterReturn oneParameterReturn = a->{
        System.out.println(" 有返回值有⼀个参数！ ");
    ret = oneParameterReturn.test(50);

（6）有返回值多个参数

interface MoreParameterReturn {
    MoreParameterReturn moreParameterReturn = (a,b)->{
        System.out.println(" 有返回值多个参数！ ");
    ret = moreParameterReturn.test(60,70);

5、变量捕获

在我们学习匿名内部类的时候我们曾经遇到过变量捕获，而我们的lambda也存在着变量捕获

（1）匿名内部类的变量捕获

        System.out.println("func()");
    public static void main(String[] args) {
                System.out.println(" 我是内部类，且重写了 func 这个⽅法！ ");
                System.out.println(" 我是捕获到变量 a == "+a +" 我是⼀个常量，或者是⼀个没有改变过值的变量！ ");

（2）Lambda的变量捕获

interface NoParameterNoReturn {
    public static void main(String[] args) {
        NoParameterNoReturn noParameterNoReturn = () -> {
            System.out.println(" 捕获变量： " + a);
        noParameterNoReturn.test();

在上述代码当中的变量a就是，捕获的变量。这个变量要么是被final修饰，如果不是被final修饰的你要保证在使用之前，没有修改。如下代码就是错误的代码

6、Lambda在集合当中的使用

（1）Collection接口

注意：Collection的 forEach()方法是从接口 java.lang.Iterable 拿过来的。

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.forEach(new Consumer<String>(){
            public void accept(String str){
                System.out.println(str+" ");
        System.out.println("==================");
        list.forEach(s -> System.out.println(s));

（2）List接口

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.sort(new Comparator<String>() {
            public int compare(String str1, String str2){
                return str1.compareTo(str2);
        System.out.println(list);
        System.out.println("==============");
        list.sort((str1,str2) -> str1.compareTo(str2));
        System.out.println(list);

（3）Map接口

    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.forEach(new BiConsumer<Integer, String>() {
            public void accept(Integer k, String v) {
                System.out.println(k + "=" + v);
        System.out.println("===============");
        map.forEach((k,v) -> System.out.println(k + "=" + v));

7、总结

Lambda表达式的优点很明显，在代码层次上来说，使代码变得非常的简洁。缺点也很明显，代码不易读。

优点：

1. 代码简洁，开发迅速
2. 方便函数式编程
3. 非常容易进行并行计算
4. Java引入Lambda，改善了集合操作

缺点：

1. 代码可读性变差
2. 在非并非计算中，很多计算未必有传统的for性能要高
3. 不容易进行调试