devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

JDK8中的重要的新特性之Lambda 表达式&&函数式接口_jdk中lambo

作者：你好赵伟 | 2024-06-16 13:09:55

赞

踩

jdk中lambo

目录

1、Lambda表达式

1.1 lambda表达式的语法

1.2 无参无返回值的Lambda

1.3 有参有返回值

1.4  Lambda表达式的省略写法

1.5  Lambda表达式使用的前提

2、内置函数式接口

2.1 内置函数式接口的由来

 2.2 消费性函数式接口Consumer

2.3 供给型函数式接口---Supplier

2.3 函数型函数式接口---Function,r>

2.4 断言型函数式接口--Predicate

  • Lambda 表达式：Lambda 表达式是 JDK 8 中最引人注目的特性之一。它们提供了一种简洁、函数式的语法，用于表示匿名函数。Lambda 表达式在集合操作、事件处理和并发编程等方面非常有用。
  • Stream API：Stream API 是一种处理集合数据的新方式。它提供了一种流式处理的方式，可以方便地进行过滤、映射、归约等操作。Stream API 可以极大地简化集合操作的代码，并且可以有效地支持并行处理。
  • 接口的默认方法：JDK 8 允许接口中定义默认方法（default methods）。默认方法是指在接口中提供一个默认的方法实现，可以直接在实现接口的类中使用或者重写。这使得在接口的演化过程中更容易向后兼容。
  • 方法引用：方法引用允许直接通过方法的名字来引用已经存在的方法。它可以使代码更简洁、易读，并且提供了对方法的复用。
  • 函数式接口：JDK 8 引入了函数式接口的概念。函数式接口是指只包含一个抽象方法的接口，它们可以被 Lambda 表达式所使用。函数式接口为函数式编程提供了基础。
  • 日期/时间 API：JDK 8 引入了新的日期和时间 API，用于替代旧的 Date 和 Calendar 类。新的日期/时间 API 提供了更好的设计和易用性，并且提供了对日期和时间的各种操作和计算。
  • CompletableFuture：CompletableFuture 是一种支持异步编程的新的工具类。它提供了方便的方法来处理异步任务的结果，包括异步任务的组合和串行化。
  • 并发增强：JDK 8 在并发编程方面进行了一些增强。它引入了新的原子类、并发集合和并发工具，以简化并发编程的开发和管理。

1、Lambda表达式

1.1 lambda表达式的语法

(参数列表)->{}
():参数列表
->:连接符 连接的是参数以及方法体。
{}: 方法体。

1.2 无参无返回值的Lambda

  1. public class Test02 {
  2.     public static void main(String[] args) {
  3.  
  4.         //匿名内部类的方式
  5.         UserService userService=new UserService() {
  6.             @Override
  7.             public void show() {
  8.                 System.out.println("这是匿名内部类的show方法的实现");
  9.             }
  10.         };
  11.         fun(userService);
  12.  
  13.         //使用lambda表达式--该接口必须为函数式接口
  14.         fun(()->{
  15.             System.out.println("这是lambda表达的show方法");
  16.         });
  17.     }
  18.     public static void fun(UserService userService){
  19.         userService.show();
  20.     }
  21. }
  22. //函数式接口：里面有且仅有一个抽象方法。  ---只有这种接口才能使用lambda表达式
  23. interface UserService{
  24.     public void show();
  25. }

1.3 有参有返回值

  1. public class Test03 {
  2.     public static void main(String[] args) {
  3.         //创建一个ArrayList集合，其中存放了"Person"对象
  4.         ArrayList<Person> list = new ArrayList<>();
  5.         //向集合中添加元素-人物姓名和年龄
  6.         list.add(new Person("张三", 19));
  7.         list.add(new Person("李四", 8));
  8.         list.add(new Person("王五", 20));
  9.         list.add(new Person("赵六", 17));
  10.         //按年龄从小到大排序
  11.         System.out.println(list);
  12.         //使用集合工具类"Collections"-  匿名内部类
  13.                 /*Collections.sort(list,  new  Comparator<Person>()  {
  14.                         @Override
  15.                         public  int  compare(Person  o1,  Person  o2)  {
  16.                                 return  o1.getAge()-o2.getAge();
  17.                         }
  18.                 });*/
  19.  
  20.         //使用Lambda表达式
  21.         Collections.sort(list, (o1, o2) -> {
  22.             //这就是对函数式接口中抽象方法的简写
  23.             return o1.getAge() - o2.getAge();
  24.         });
  25.         //输出按年龄从小到大排序的结果
  26.         System.out.println(list);
  27.     }
  28. }
  29.  
  30. class Person {
  31.     private String name;
  32.     private Integer age;
  33.     public Person() {
  34.     }
  35.     public Person(String name, Integer age) {
  36.         this.name = name;
  37.         this.age = age;
  38.     }
  39.     
  40.     /**
  41.      * 获取
  42.      *
  43.      * @return name
  44.      */
  45.     public String getName() {
  46.         return name;
  47.     }
  48.  
  49.     /**
  50.      * 设置
  51.      *
  52.      * @param name
  53.      */
  54.     public void setName(String name) {
  55.         this.name = name;
  56.     }
  57.  
  58.     /**
  59.      * 获取
  60.      *
  61.      * @return age
  62.      */
  63.     public Integer getAge() {
  64.         return age;
  65.     }
  66.  
  67.     /**
  68.      * 设置
  69.      *
  70.      * @param age
  71.      */
  72.     public void setAge(Integer age) {
  73.         this.age = age;
  74.     }
  75.  
  76.     public String toString() {
  77.         return "Person{name = " + name + ", age = " + age + "}";
  78.     }
  79. }

1.4  Lambda表达式的省略写法

 在lambda表达式的标准写法基础上，可以使用省略写法的规则为：

  1. 小括号内的参数类型可以省略[]

  2. 如果小括号内有且仅有一个参数，则小括号可以省略

  3. 如果大括号内有且仅有一个语句，可以同时省略大括号，return 关键字及语句分号。

  1. public class Test04 {
  2.     public static void main(String[] args) {
  3.         
  4.         fun((str)->
  5.             str.toUpperCase()
  6.         );
  7.     }
  8.     public static void fun(USB usb){
  9.         String s = usb.toUpper("hello");
  10.         System.out.println(s);
  11.     }
  12. }
  13. interface USB{
  14.     public String toUpper(String str);
  15. }

1.5  Lambda表达式使用的前提

 Lambda表达式的语法是非常简洁的，但是Lambda表达式不是随便使用的，使用时有几个条件要特别注意

  1. 方法的参数或局部变量类型必须为接口才能使用Lambda

  2. 接口中有且仅有一个抽象方法(@FunctionalInterface)

后面我们使用lambda表达式主要核心使用再Stream流中。

2、内置函数式接口

要想使用lambda表达式它的前提就是必须是函数式接口。

2.1 内置函数式接口的由来

  1. public class Test {
  2.     public static void main(String[] args) {
  3.  
  4.         fun(arr->{
  5.             int sum = 0;
  6.             for (int i : arr) {
  7.                 sum+=i;
  8.             }
  9.             return sum;
  10.         });
  11.     }
  12.     public static void fun(Operation operation){
  13.         int[] arr = {1,2,3,4,5};
  14.         int sum = operation.getSum(arr);
  15.         System.out.println("数组的和："+sum);
  16.     }
  17. }
  18. @FunctionalInterface
  19. interface Operation{
  20.     public int getSum(int[] arr);
  21. }

分析：

我们知道使用Lambda表达式的前提是需要有函数式接口，而Lambda表达式使用时不关心接口名，抽象方法名。只关心抽象方法的参数列表和返回值类型。因此为了让我们使用Lambda表达式更加的方便，在JDK中提供了大量常用的函数式接口. 大多数无需自己再定义函数式接口，而可以直接使用jdk内置的函数式接口。分成四类。

 2.2 消费性函数式接口Consumer

适合有参数，但是没有返回值的。

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         /*Consumer<Double> consumer = t->{
  4.             System.out.println("今天坐车花费了" + t + "元");
  5.         };*/
  6.         
  7.             fun(t->{
  8.                 System.out.println("今天坐车花费了" + t + "元");
  9.             },200.00);
  10.     }
  11.     public static void fun(Consumer<Double> consumer,Double money){
  12.         consumer.accept(money);
  13.     }
  14. }

2.3 供给型函数式接口---Supplier

无参，需要返回值的接口类。

  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.         fun(()->{
  4.             return new Random().nextInt(10);
  5.         });
  6.     }
  7.     public static void fun(Supplier<Integer> supplier){
  8.         Integer i = supplier.get();
  9.         System.out.println("结果:" + i);
  10.     }
  11. }

2.3 函数型函数式接口---Function<T,R>

T: 参数的泛型

R:返回值的泛型。

  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.  
  4.        fun2(t->t.toUpperCase(),"hello world");
  5.  
  6.     }
  7.  
  8.     public static void fun2(Function<String,String> function,String str){
  9.         String apply = function.apply(str);
  10.         System.out.println("结果:" + apply);
  11.     }
  12.  
  13.     
  14. }

2.4 断言型函数式接口--Predicate

T: 参数

boolean:返回值类型。

  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.  
  4.         //Predicate断言型
  5.         fun3(t->t>=18,18);
  6.     }
  7.     public static void fun3(Predicate<Integer> predicate,Integer age){
  8.         boolean test = predicate.test(age);
  9.         System.out.println("是否成年:"+test);
  10.     }
  11. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/726768
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号