Lamda表达式

Lambda表达式并不能简化所以匿名内部类的写法。
只能简化接口中只有一个抽象方法的匿名内部类形式。
@FunctionalInterface函数式接口注解：
一旦某个接口加上了这个注解，这个接口只能有且只有一个抽象方法。

Lambda表达式的省略写法:
1.如果表达式的方法体代码只有一行代码。可以省略大括号不写，同时要省略分号！
2.如果表达式的方法体代码只有一行代码。省略大括号不写，如果这行代码是return语句，必须省略return不写，“；”不写。
3.参数类型可以省略不写
4.如果只有一个参数，参数类型可以省略，同时（）也可以省略。

public class demo01 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        

        //1.匿名内部类
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        //2.省略前面的函数类型
        list.forEach((String s) ->{
            System.out.println(s);
        });

        //3.省略参数类型/小括号
        list.forEach(s->{
            System.out.println(s);
        });

        //4.省略大括号，分号
        list.forEach(s->System.out.println(s));

        //5.方法引用
        list.forEach(System.out::println);

    }
}

1.正常实现

interface MyInterface{

    void lMethod();
}
 class My implements MyInterface{

    @Override
    public void lMethod() {
        System.out.println("Hello World!");
    }
}
public class  Lamda{
    public static void main(String[] args) {
        
        My my = new My();
        my.lMethod();
    }
    }

2.静态内部类

package com.example.test;

interface MyInterface{

    void lMethod();
}

public class  Lamda{

    //静态内部类
    static class My implements MyInterface{

        @Override
        public void lMethod() {
            System.out.println("Hello World!");
        }
    }

    public static void main(String[] args) {

        My my = new My();
        my.lMethod();
    }

    }

3.局部内部类

package com.example.test;

interface MyInterface{

    void lMethod();
}

public class  Lamda{

    public static void main(String[] args) {

        //局部内部类
        class My implements MyInterface{
            @Override
            public void lMethod() {
                System.out.println("Hello World!");
            }
        }

        My my = new My();
        my.lMethod();
    }

    }

4.匿名内部类

package com.example.test;

interface MyInterface{

   void lMethod();
}

public class  Lamda{

   public static void main(String[] args) {
       
       //匿名内部类
       MyInterface my = new MyInterface(){

            @Override
            public void lMethod() {
                System.out.println("Hello World!");
            }
        };
       my.lMethod();
   }

   }

5.Lamda表达式

package com.example.test;

interface MyInterface{

    void lMethod();
}

public class  Lamda{

    public static void main(String[] args) {

        //Lamda表达式
        MyInterface my = ()->{
                 System.out.println("Hello World!");
         };
        my.lMethod();
    }

    }

作者：Mingqi
链接：https://www.zhihu.com/question/20125256/answer/324121308
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

image.png

什么是Lambda?

我们知道，对于一个Java变量，我们可以赋给其一个“值”。

image.png

如果你想把“一块代码”赋给一个Java变量，应该怎么做呢？

比如，我想把右边那块代码，赋给一个叫做aBlockOfCode的Java变量：

image.png

在Java 8之前，这个是做不到的。但是Java 8问世之后，利用Lambda特性，就可以做到了。

image.png

当然，这个并不是一个很简洁的写法。所以，为了使这个赋值操作更加elegant, 我们可以移除一些没用的声明。

image.png

这样，我们就成功的非常优雅的把“一块代码”赋给了一个变量。而“这块代码”，或者说“这个被赋给一个变量的函数”，就是一个Lambda表达式。

但是这里仍然有一个问题，就是变量aBlockOfCode的类型应该是什么？

在Java 8里面，所有的Lambda的类型都是一个接口，而Lambda表达式本身，也就是”那段代码“，需要是这个接口的实现。这是我认为理解Lambda的一个关键所在，简而言之就是，Lambda表达式本身就是一个接口的实现。直接这样说可能还是有点让人困扰，我们继续看看例子。我们给上面的aBlockOfCode加上一个类型：