Lambda表达式的演变过程

本文将为你用代码展示lambda的演变过程。

使用Lambda表达式首先要明白它的好处是什么？

1. 避免匿名内部类定义过多；
2. 可以让代码看起来更简洁；
3. 去掉了一堆没有意义的代码，只留下核心的逻辑。

演变一：

1. 定义一个函数式接口

2. 用一个类去实现这个接口，然后实现它的方法

3. 接口去new实现类

4. 代码演示

   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}

标签：演变,show,void,接口,User,UserService,public,表达式,Lambda
来源： https://blog.csdn.net/weixin_44603382/article/details/121375301