本文将为你用代码展示lambda的演变过程。
使用Lambda表达式首先要明白它的好处是什么？
- 避免匿名内部类定义过多；
- 可以让代码看起来更简洁；
- 去掉了一堆没有意义的代码，只留下核心的逻辑。
演变一：
-
定义一个函数式接口
-
用一个类去实现这个接口，然后实现它的方法
-
接口去new实现类
-
代码演示
public class TestLambda { public static void main(String[] args) { // 接口去new实现类 UserService service = new UserServiceImpl(); service.show();// 执行了show()... } } // 1、定义一个函数式接口 // 任何接口，如果只包含唯一一个抽象方法，那么他就是一个函数式接口 interface UserService { void show(); } // 2、实现类 class UserServiceImpl implements UserService { @Override public void show() { System.out.println("执行了show()..."); } }
演变二：静态内部类
使用静态内部类，就是将接口的实现类放在具体的类中。
package com.ls.lambda;
// 推导Lambda表达式
public class TestLambda {
// 2、实现类
static class UserServiceImpl implements UserService {
@Override
public void show() {
System.out.println("执行了show()...");
}
}
public static void main(String[] args) {
UserService service = new UserServiceImpl();
service.show();// 执行了show()...
}
}
// 1、定义一个函数式接口
interface UserService {
void show();
}
演变三：局部内部类
局部内部类，将接口的实现类放入方法中。
package com.ls.lambda;
// 推导Lambda表达式
public class TestLambda {
public static void main(String[] args) {
// 2、实现类
class UserServiceImpl implements UserService {
@Override
public void show() {
System.out.println("执行了show()...");
}
}
UserService service = new UserServiceImpl();
service.show();// 执行了show()...
}
}
// 1、定义一个函数式接口
interface UserService {
void show();
}
演变四：匿名内部类
匿名内部类：没有类的名称，必须借助接口或者父类。
package com.ls.lambda;
// 推导Lambda表达式
public class TestLambda {
public static void main(String[] args) {
// 2、实现类
UserService service = new UserService() {
@Override
public void show() {
System.out.println("执行了show()...");
}
};
service.show();// 执行了show()...
}
}
// 1、定义一个函数式接口
interface UserService {
void show();
}
演变五：lambda（无参无返回值）
接口只有一个类，类中只有一个方法
package com.ls.lambda;
// 推导Lambda表达式
public class TestLambda {
public static void main(String[] args) {
// 使用lambda简化
UserService service = () -> {
System.out.println("执行了show()...");
};
service.show();// 执行了show()...
}
}
// 1、定义一个函数式接口
interface UserService {
void show();
}
二、有参有返回值的lambda
// 创建一个User对象
private String name;
private int age;
然后在List集合中保存多个User对象，然后根据这些对象进行age排序操作
ArrayList<User> list = new ArrayList<>();
list.add(new User("张三", 18));
list.add(new User("李四", 20));
list.add(new User("王五", 16));
Collections.sort(list, new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return o1.getAge() - o2.getAge();
}
});
for (Person person : list) {
System.out.println(person);
}
User{name='王五', age=16}
User{name='张三', age=18}
User{name='李四', age=20}
我们发现在sort方法的第二个参数是一个Comparator接口的匿名内部类，且执行的方法有参数和方法返回值，那么可以改写成lambda表达式。
Collections.sort(list, (User o1, User o2) -> {
return o1.getAge() - o2.getAge();
});
for (User user:list) {
System.out.println(user);
}
输出
User{name='王五', age=16}
User{name='张三', age=18}
User{name='李四', age=20}