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

JDK8的新特性--Lambda表达式_;&$clalho8&菧@mhvo)

作者：从前慢现在也慢 | 2024-06-16 13:14:34

赞

踩

;&$clalho8&菧@mhvo)

lambda表达式

概念: 语法:

注意: 函数式接口:接口中只有一个抽象方法。

(参数1，参数2): 抽象方法的参数

->: 分隔符

{}：表示抽象方法的实

例子:

  1. package com.demo01;
  2.  
  3. /**
  4.  * @Author Li Qinghua
  5.  * @Create 2022/7/19 14:38
  6.  */
  7. public class TestLambda {
  8.     public static void main(String[] args) {
  9.         //匿名内部类
  10.         Runnable r1=new Runnable() {
  11.             @Override
  12.             public void run() {
  13.                 System.out.println("Runnable");
  14.             }
  15.         };
  16.         Thread t1=new Thread(r1);
  17.         t1.start();
  18.  
  19.  
  20.         Runnable r2=()->{
  21.             System.out.println("这是Lambda表达式的Runnable");
  22.         };
  23.         Thread t2=new Thread(r2);
  24.         t2.start();
  25.  
  26.         Thread t3=new Thread(()->{
  27.             System.out.println("这是Lambda表达式的匿名内部Runnable");
  28.         });
  29.         t3.start();
  30.     }
  31. }

分析代码:

  • Thread 类需要 Runnable 接口作为参数，其中的抽象 run 方法是用来指定线程任务内容的核心

  • 为了指定 run 的方法体，不得不需要 Runnable 接口的实现类

  • 为了省去定义一个 Runnable 实现类的麻烦，不得不使用匿名内部类

  • 必须覆盖重写抽象 run 方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错

  • 而实际上，似乎只有方法体才是关键所在。

这时可以使用lambda表示完成上面的要求。

前提:必须是函数式接口。

简化匿名内部类的使用，语法更加简单。

1 .无参无返回值

  1. package com.demo03;
  2.  
  3. /**
  4.  * @Author Li Qinghua
  5.  * @Create 2022/7/19 15:34
  6.  */
  7. public class TestSwim {
  8.     public static void main(String[] args) {
  9.         method(()-> System.out.println("在游泳"));
  10.     }
  11.  
  12.     public static void method(Swim s){
  13.         s.swim();
  14.     }
  15. }
  16.  
  17. @FunctionalInterface
  18. interface Swim{
  19.     public void swim();
  20. }

2 有参数有返回值的Lambda

下面举例演示 java.util.Comparator 接口的使用场景代码，其中的抽象方法定义为：

  • public abstract int compare(T o1, T o2);

当需要对一个对象集合进行排序时， Collections.sort 方法需要一个 Comparator 接口实例来指定排序的规则。

  1. package com.demo02;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.Comparator;
  6. import java.util.List;
  7.  
  8. /**
  9.  * @Author Li Qinghua
  10.  * @Create 2022/7/19 15:08
  11.  */
  12. public class TestStudentSort {
  13.     public static void main(String[] args) {
  14.         List<Student> list=new ArrayList<>();
  15.         list.add(new Student("李MM",29,176));
  16.         list.add(new Student("李PP",19,174));
  17.         list.add(new Student("李AA",23,183));
  18.         list.add(new Student("李RR",22,179));
  19.  
  20.         Comparator<Student> comparator=new Comparator<Student>() {
  21.             @Override
  22.             public int compare(Student o1, Student o2) {
  23.                 return o2.getAge()-o1.getAge();
  24.             }
  25.         };
  26.  
  27.         Collections.sort(list,comparator);
  28.  
  29.         for(Student s:list){
  30.             System.out.println(s);
  31.         }
  32.  
  33.         System.out.println("=================");
  34.  
  35.         Comparator<Student> comparator1=(Student s1,Student s2)->{
  36.             return (int) (s2.getHigh()-s1.getHigh());
  37.         };
  38.  
  39.         Collections.sort(list,comparator1);
  40.         for(Student s:list){
  41.             System.out.println(s);
  42.         }
  43.  
  44.         System.out.println("============");
  45.         Collections.sort(list,(o1,o2)-> o2.getAge()-o1.getAge());
  46.         for(Student s:list){
  47.             System.out.println(s);
  48.         }
  49.     }
  50. }
  51.  
  52. class Student{
  53.     private String name;
  54.     private int age;
  55.     private double high;
  56.  
  57.     @Override
  58.     public String toString() {
  59.         return "Student{" +
  60.                 "name='" + name + '\'' +
  61.                 ", age=" + age +
  62.                 ", high=" + high +
  63.                 '}';
  64.     }
  65.  
  66.     public Student(String name, int age, double high) {
  67.         this.name = name;
  68.         this.age = age;
  69.         this.high = high;
  70.     }
  71.  
  72.     public String getName() {
  73.         return name;
  74.     }
  75.  
  76.     public void setName(String name) {
  77.         this.name = name;
  78.     }
  79.  
  80.     public int getAge() {
  81.         return age;
  82.     }
  83.  
  84.     public void setAge(int age) {
  85.         this.age = age;
  86.     }
  87.  
  88.     public double getHigh() {
  89.         return high;
  90.     }
  91.  
  92.     public void setHigh(double high) {
  93.         this.high = high;
  94.     }
  95. }

3.详细介绍lambda表达式

4. 函数式接口

 内置函数式接口的由来

  1. public class Test03 {
  2.  
  3.     public static void main(String[] args) {
  4.         Operater o=arr -> {
  5.              int sum=0;
  6.              for(int n:arr){
  7.                  sum+=n;
  8.              }
  9.             System.out.println("数组的和为:"+sum);
  10.         };
  11.  
  12.         fun(o);
  13.     }
  14.  
  15.     public static void fun(Operater operater){
  16.          int[] arr={2,3,4,5,6,7,11};
  17.          operater.getSum(arr);
  18.     }
  19.  
  20. }
  21. @FunctionalInterface
  22. interface Operater{
  23.     //求数组的和
  24.     public abstract void getSum(int[] arr);
  25. }

分析

我们知道使用Lambda表达式的前提是需要有函数式接口。而Lambda使用时不关心接口名，抽象方法名，只关心抽 象方法的参数列表和返回值类型。因此为了让我们使用Lambda方便，JDK提供了大量常用的函数式接口。

常见得函数式接口

java.util.function保存

4.1 Consumer<T>

有参数，无返回值。

  1. package edu.demo04;
  2.  
  3. import java.util.function.Consumer;
  4.  
  5. /**
  6.  * @Author Li Qinghua
  7.  * @Create 2022/7/19 20:36
  8.  */
  9. public class Test01 {
  10.     public static void main(String[] args) {
  11.  
  12.         Consumer<Integer[]> c=nums->{
  13.           int sum=0;
  14.           for(int n:nums){
  15.               sum+=n;
  16.           }
  17.             System.out.println(sum);
  18.         };
  19.  
  20.         method(c);
  21.     }
  22.  
  23.     //调用某个方法时，该方法需要的参数为接口类型，这时就应该能想到使用lambda
  24.     public static void method(Consumer<Integer[]> consumer){
  25.         Integer[] arr={1,2,3,4,5};
  26.         consumer.accept(arr);
  27.     }
  28. }

4.2 Supplier<T>供给型函数式接口

T:表示返回结果的泛型

无参，想有返回结果的函数式接口时使用Supplier

T get();

  1. package edu.demo04;
  2.  
  3. import java.util.function.Supplier;
  4.  
  5. /**
  6.  * @Author Li Qinghua
  7.  * @Create 2022/7/19 20:59
  8.  */
  9. public class Test02 {
  10.     public static void main(String[] args) {
  11.         method(()->{
  12.           return "Hello World";
  13.         });
  14.     }
  15.  
  16.     public static void method(Supplier<String> supplier){
  17.         String str = supplier.get();
  18.         System.out.println(str);
  19.     }
  20. }

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

T: 参数类型的泛型

R: 函数返回结果的泛型

有参，有返回 值时。

例子: 传入一个学生的姓名，求出该学生的年龄或者姓名。

  1. package edu.demo04;
  2.  
  3. import java.util.function.Function;
  4.  
  5. /**
  6.  * @Author Li Qinghua
  7.  * @Create 2022/7/19 21:04
  8.  */
  9. public class Test03 {
  10.     public static void main(String[] args) {
  11.         Function<Student,Integer> function=(stu)->{
  12.             return stu.getAge();
  13.         };
  14.  
  15.         method(function);
  16.     }
  17.  
  18.     public static void method(Function<Student,Integer> function){
  19.         Integer age = function.apply(new Student("李QQ", 23));
  20.         System.out.println(age);
  21.     }
  22. }
  23.  
  24. class Student{
  25.     private String name;
  26.     private int age;
  27.  
  28.     public Student(String name, int age) {
  29.         this.name = name;
  30.         this.age = age;
  31.     }
  32.  
  33.     public String getName() {
  34.         return name;
  35.     }
  36.  
  37.     public void setName(String name) {
  38.         this.name = name;
  39.     }
  40.  
  41.     public int getAge() {
  42.         return age;
  43.     }
  44.  
  45.     public void setAge(int age) {
  46.         this.age = age;
  47.     }
  48.  
  49.     @Override
  50.     public String toString() {
  51.         return "Student{" +
  52.                 "name='" + name + '\'' +
  53.                 ", age=" + age +
  54.                 '}';
  55.     }
  56. }

4.4 Predicated<T>

T: 参数的泛型

boolean test(T t);

当传入一个参数时，需要对该参数进行判断时，则需要这种函数。

  1. package com.demo07;
  2.  
  3. import java.util.function.Predicate;
  4.  
  5. /**
  6.  * @Author Li Qinghua
  7.  * @Create 2022/7/19 16:50
  8.  */
  9. public class TestPredicated {
  10.     public static void main(String[] args) {
  11.         method(name->name.length()>3?true:false,"雷霆嘎巴");
  12.     }
  13.  
  14.     public static void method(Predicate<String> predicate,String name){
  15.  
  16.         boolean b = predicate.test(name);
  17.         System.out.println(b);
  18.     }
  19. }

5. 方法引用

5.1 lambda表达式的冗余

  1. package com.demo08;
  2.  
  3. import java.util.function.Consumer;
  4.  
  5. /**
  6.  * @Author Li Qinghua
  7.  * @Create 2022/7/19 19:04
  8.  * lambda 冗余  静态方法引用
  9.  */
  10. public class Test01 {
  11.     public static void main(String[] args) {
  12.         Consumer<Integer> c1=(num)->{
  13.             int sum=0;
  14.             for (int i = 0; i <= num; i++) {
  15.                 sum+=i;
  16.             }
  17.             System.out.println(sum);
  18.         };
  19.        
  20.         method(c1,100);
  21.        
  22.         getSum(100);
  23.     }
  24.  
  25.     public static void method(Consumer<Integer> consumer,Integer num){
  26.         consumer.accept(num);
  27.     }
  28.  
  29.     public static void getSum(Integer num){
  30.         int sum=0;
  31.         for (int i = 0; i <=num; i++) {
  32.             sum+=i;
  33.         }
  34.         System.out.println("和为："+sum);
  35.     }
  36. }

分析:

如果我们在Lambda中所指定的功能，已经有其他方法存在相同方案，那是否还有必要再写重复逻辑？可以直接“引 用”过去就好了：---方法引用。

静态方法引用

  1. package com.demo08;
  2.  
  3. import java.util.function.Consumer;
  4.  
  5. /**
  6.  * @Author Li Qinghua
  7.  * @Create 2022/7/19 19:04
  8.  * lambda 冗余  静态方法引用
  9.  */
  10. public class Test01 {
  11.     public static void main(String[] args) {
  12.         /*Consumer<Integer> c1=(num)->{
  13.             int sum=0;
  14.             for (int i = 0; i <= num; i++) {
  15.                 sum+=i;
  16.             }
  17.             System.out.println(sum);
  18.         };*/
  19.         Consumer<Integer> c2=Test01::getSum;
  20.  
  21.         //method(c1,100);
  22.         method(c2,100);
  23.         //getSum(100);
  24.     }
  25.  
  26.     public static void method(Consumer<Integer> consumer,Integer num){
  27.         consumer.accept(num);
  28.     }
  29.  
  30.     public static void getSum(Integer num){
  31.         int sum=0;
  32.         for (int i = 0; i <=num; i++) {
  33.             sum+=i;
  34.         }
  35.         System.out.println("和为："+sum);
  36.     }
  37. }

请注意其中的双冒号 :: 写法，这被称为“方法引用”，是一种新的语法。

5.2 什么是方法引用

 方法引用的分类

5.3 实例方法引用

实例方法引用，顾名思义就是调用已经存在的实例的方法，与静态方法引用不同的是类要先实例化，静态方法引用类无需实例化，直接用类名去调用。

  1. package com.demo08;
  2.  
  3. import java.util.function.Supplier;
  4.  
  5. /**
  6.  * @Author Li Qinghua
  7.  * @Create 2022/7/19 19:30
  8.  */
  9. public class Test03 {
  10.     public static void main(String[] args) {
  11.         /*Person[] people={new Person("李AA",19),new Person("李UU",23),new Person("李NN",21)
  12.                 new Person("李OO",16)};*/
  13.         Person p=new Person("李AA",23);
  14.         Supplier<String> supplier=p::getName;
  15.  
  16.         method(supplier);
  17.     }
  18.  
  19.     public static void method(Supplier<String> supplier){
  20.         String s = supplier.get();
  21.         System.out.println(s);
  22.     }
  23. }
  24.  
  25. class Person{
  26.     private String name;
  27.     private int age;
  28.  
  29.     public static int compareTo(Person p1,Person p2){
  30.         return p2.getAge()-p1.getAge();
  31.     }
  32.  
  33.     @Override
  34.     public String toString() {
  35.         return "Person{" +
  36.                 "name='" + name + '\'' +
  37.                 ", age=" + age +
  38.                 '}';
  39.     }
  40.  
  41.     public String getName() {
  42.         return name;
  43.     }
  44.  
  45.     public void setName(String name) {
  46.         this.name = name;
  47.     }
  48.  
  49.     public int getAge() {
  50.         return age;
  51.     }
  52.  
  53.     public void setAge(int age) {
  54.         this.age = age;
  55.     }
  56.  
  57.     public Person(String name, int age) {
  58.         this.name = name;
  59.         this.age = age;
  60.     }
  61. }
  62.

5.4对象方法引用

类名::实例方法. (参数1,参数2)->参数1.实例方法(参数2)

  1. package edu.demo05;
  2.  
  3. import java.util.function.BiFunction;
  4. import java.util.function.Consumer;
  5. import java.util.function.Function;
  6. import java.util.function.Supplier;
  7.  
  8. /**
  9.  * @Author Li Qinghua
  10.  * @Create 2022/7/20 14:40
  11.  */
  12. public class Test03 {
  13.     public static void main(String[] args) {
  14.         Function<String,Integer> function=String::length;
  15.         Integer len = function.apply("abc");
  16.         System.out.println(len);
  17.  
  18.         System.out.println("~~~~~~~~~~~");
  19.  
  20.         //比较两个字符串的内容是否一致.T, U, R
  21.         BiFunction<String,String,Boolean> bi=String::equals;
  22.         Boolean b = bi.apply("abc", "efg");
  23.         System.out.println(b);
  24.  
  25.         System.out.println("~~~~~~~~~~");
  26.  
  27.         Function<String,People> function1=People::new;
  28.         People person = function1.apply("李四");
  29.         System.out.println(person);
  30.     }
  31. }
  32.  
  33. class People{
  34.     private String name;
  35.  
  36.     public People() {
  37.     }
  38.  
  39.     public People(String name) {
  40.         this.name = name;
  41.     }
  42.  
  43.     public String getName() {
  44.         return name;
  45.     }
  46.  
  47.     public void setName(String name) {
  48.         this.name = name;
  49.     }
  50.  
  51.     @Override
  52.     public String toString() {
  53.         return "People{" +
  54.                 "name='" + name + '\'' +
  55.                 '}';
  56.     }
  57. }

5.4构造方法引用

类名::new         (参数)->new 类名(参数)

  1. Function<String,People> function1=People::new;
  2.         People person = function1.apply("李四");
  3.         System.out.println(person);

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

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

  

闽ICP备14008679号