Lambda表达式并不能简化所以匿名内部类的写法。
只能简化接口中只有一个抽象方法的匿名内部类形式。
@FunctionalInterface函数式接口注解：
一旦某个接口加上了这个注解，这个接口只能有且只有一个抽象方法。
Lambda表达式的省略写法:
1.如果表达式的方法体代码只有一行代码。可以省略大括号不写，同时要省略分号！
2.如果表达式的方法体代码只有一行代码。省略大括号不写，如果这行代码是return语句，必须省略return不写，“；”不写。
3.参数类型可以省略不写
4.如果只有一个参数，参数类型可以省略，同时（）也可以省略。
public class demo01 {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
//1.匿名内部类
list.forEach(new Consumer() {
@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
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
什么是Lambda?
我们知道，对于一个Java变量，我们可以赋给其一个“值”。
如果你想把“一块代码”赋给一个Java变量，应该怎么做呢？
比如，我想把右边那块代码，赋给一个叫做aBlockOfCode的Java变量：
在Java 8之前，这个是做不到的。但是Java 8问世之后，利用Lambda特性，就可以做到了。
当然，这个并不是一个很简洁的写法。所以，为了使这个赋值操作更加elegant, 我们可以移除一些没用的声明。
这样，我们就成功的非常优雅的把“一块代码”赋给了一个变量。而“这块代码”，或者说“这个被赋给一个变量的函数”，就是一个Lambda表达式。
但是这里仍然有一个问题，就是变量aBlockOfCode的类型应该是什么？
在Java 8里面，所有的Lambda的类型都是一个接口，而Lambda表达式本身，也就是”那段代码“，需要是这个接口的实现。这是我认为理解Lambda的一个关键所在，简而言之就是，Lambda表达式本身就是一个接口的实现。直接这样说可能还是有点让人困扰，我们继续看看例子。我们给上面的aBlockOfCode加上一个类型：
这种只有一个接口函数需要被实现的接口类型，我们叫它”函数式接口“。为了避免后来的人在这个接口中增加接口函数导致其有多个接口函数需要被实现，变成"非函数接口”，我们可以在这个上面加上一个声明@FunctionalInterface, 这样别人就无法在里面添加新的接口函数了：
这样，我们就得到了一个完整的Lambda表达式声明：
Lambda表达式有什么作用?
最直观的作用就是使得代码变得异常简洁。
我们可以对比一下Lambda表达式和传统的Java对同一个接口的实现：
这两种写法本质上是等价的。但是显然，Java 8中的写法更加优雅简洁。并且，由于Lambda可以直接赋值给一个变量，我们就可以直接把Lambda作为参数传给函数, 而传统的Java必须有明确的接口实现的定义，初始化才行：
有些情况下，这个接口实现只需要用到一次。传统的Java 7必须要求你定义一个“污染环境”的接口实现MyInterfaceImpl，而相较之下Java 8的Lambda, 就显得干净很多。