其他分享
首页 > 其他分享> > Lambda表达式的演变过程

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