Lambda表达式详解

绝地灬酷狼 2024-04-03 10:41 65阅读 0赞

#### 文章目录 ####

*  前言
 *  一、从匿名内部类到Lambda表达式
 *  二、Lambda表达式的语法
 *   *  1.语法格式1：无参无返回值（指的是函数式接口的方法）
     *  2.语法格式2：有参无返回值
     *  3.语法格式3：当只有一个参数时，参数的小括号可以省略
     *  4.语法格式4：有参有返回值
     *  5.语法格式5：当只有一条语句体，return 和大括号可以省略
     *  6.语法格式6：参数类型可以省略不写，编译器会自动进行上下文的类型推断
 *  三、函数式接口
 *   *  1.什么是函数式接口？
     *  2.自定义函数式接口
     *  3.作为参数传递的Lambda表达式
     *  4.Java内置的四个函数式接口
     *   *  消费型接口Consumer< T >
         *  供给型接口Supplier< T >
         *  函数型接口Function< T >
         *  断定型接口Predicate< T >
 *  四、方法引用与构造引用
 *   *  1、方法引用
     *  2、构造引用
 *  总结

--------------------

## 前言 ##

Lambda表达式是JDK1.8的新特性，本篇来学习Lambda表达式

--------------------

## 一、从匿名内部类到Lambda表达式 ##

> Lambda表达式实质上是匿名内部类的一种变型

首先使用maven新建一个java项目  
，导入junit单元测试依赖，需要注意的是，我们可以把< scope>标签给删除，以此来让我们的项目的每一个包都可以使用@Test注解  
案例：  
使用Lambda表达式new一个接口

public class LambdaDemo1 {
        
           @Test
           public void test(){
        
               //使用匿名内部类new一个接口
               Runnable r1 = new Runnable() {
        
                   @Override
                   public void run() {
        
                       System.out.println("hello world！！");
                   }
               };
                r1.run();
               //使用Lambda表达式
               Runnable r2 = () -> System.out.println("hello world");
               r2.run();
           }
    }

案例：使用匿名内部类进行参数传递

@Test
        public void test1(){
        
           //使用匿名内部类作为参数传递 以TreeSet集合为例
            TreeSet<String> t1 = new TreeSet<>(new Comparator<String>() {
        
                @Override
                public int compare(String o1, String o2) {
        
                    return o1.length()-o2.length();
                }
            });
            //使用Lambda表达式
            TreeSet<String> t2 = new TreeSet<>(
                    (o1,o2) -> Integer.compare(o1.length(),o2.length())
            );
        }

## 二、Lambda表达式的语法 ##

> Lambda表达式在java语言中引入了一个新的语法元素和操作符，箭头符号 \->  
> 该符号被称作Lambda操作符或者箭头操作符，它将Lambda表达式分为两个部分  
> 左侧：指定了Lambda表达式需要的参数 对应函数式接口的方法参数  
> 右侧：指定了Lambda表达式体，即表达式所要完成的功能 对应函数式接口的方法体  
> Lambda表达式需要函数式接口的支持？什么是函数式接口，即这个接口只有一个抽象方法  
> 一般来讲，函数式接口会有一个注解@FunctionalInterface来标注，注意，被该注解标注一定是  
> 函数式接口，没有被标注，也不一定不是函数式接口  
> Lambda表达式就是根据函数式接口的方法来编写的。

### 1.语法格式1：无参无返回值（指的是函数式接口的方法） ###

@Test
        public void test2(){
        
            Runnable r2 = () -> System.out.println("hello world");
            r2.run();
        }

### 2.语法格式2：有参无返回值 ###

@Test
        public void test3(){
        
            Consumer<String> c1 = (str) -> System.out.println(str);
            c1.accept("这是参数");
        }

### 3.语法格式3：当只有一个参数时，参数的小括号可以省略 ###

@Test
        public void test4(){
        
            Consumer<String> c1 = str -> System.out.println(str);
            c1.accept("这是参数");
        }

### 4.语法格式4：有参有返回值 ###

@Test
        public void test5(){
        
            BinaryOperator<Integer> b1 = (num1,num2) ->{
        
                System.out.println("实现了有参有返回值");
              return num1+num2;
            };
            System.out.println(b1.apply(2,3));
        }

### 5.语法格式5：当只有一条语句体，return 和大括号可以省略 ###

@Test
        public void test6(){
        
            BinaryOperator<Integer> b1 = (num1,num2) -> num1+num2;
            System.out.println(b1.apply(2,3));
        }

### 6.语法格式6：参数类型可以省略不写，编译器会自动进行上下文的类型推断 ###

--------------------

## 三、函数式接口 ##

### 1.什么是函数式接口？ ###

> 函数式接口就是只有一个抽象方法的接口。被称为函数式接口  
> 可以通过Lambda表达式来创建函数式接口的对象  
> 可以在任意函数式接口上使用@FunctionalInterface来标注当前接口是一个函数式接口

### 2.自定义函数式接口 ###

我们可以使用注解来自定义函数式接口  
![在这里插入图片描述][3538a82643dc4562b144d6e3fb85a02e.png]

### 3.作为参数传递的Lambda表达式 ###

Lambda表达式本质上是一个函数式接口的实例对象  
我们可以把Lambda表达式当作一个方法的参数传递  
案例：  
![在这里插入图片描述][2f1c2538115e4fffa6690fa2b46c5d0f.png]

### 4.Java内置的四个函数式接口 ###

#### 消费型接口Consumer< T > ####

消费型接口Consumer< T > 参数为T 返回值为void void accept(T t)

@Test
        public void test(){
        
            playGame(12.0,(money)->{
        
                System.out.println("电竞区体验感十足，可以办个会员,网费为："+money+"每小时");
            });
    
        }
        public void playGame(Double money, Consumer<Double> consumer){
        
            consumer.accept(money);
        }

运行结果：  
![在这里插入图片描述][ece0a6c57985425bb3261366b7270b72.png]

#### 供给型接口Supplier< T > ####

供给型接口Supplier< T > 无参数 有返回值 T get()

@Test
        public void test1(){
        
           study(() -> "好好学习，天天向上" );
        }
        public void study(Supplier<String> supplier){
        
            String s = supplier.get();
            System.out.println(s);
        }

运行结果：  
![在这里插入图片描述][4ffb73ebbd6849e0bda1238f4a82f8c7.png]

#### 函数型接口Function< T > ####

函数型接口Function< T > 参数类型为T 返回值为R 对类型为T的参数进行加工返回值为R类型的结果 apply(T t)

@Test
        public void test2(){
        
            study("HELLO WORLD",(str) -> {
        
                return str.toLowerCase();
            });
        }
        public void study(String str, Function<String,String> function){
        
            String s = function.apply(str);
            System.out.println(s);
        }

执行结果：  
![在这里插入图片描述][a4c221ae62b14be896ad2f5003150de4.png]

#### 断定型接口Predicate< T > ####

断定型接口Predicate< T > 参数类型为T 返回值为boolean 对参数T的类型进行判断 看是否满足条件 boolean test(T t)

@Test
        public void test3(){
        
            List<Integer> integers = Arrays.asList(1,2,3,4,5,6,7,8,9);
            List<Integer> num1 = getNum(integers, (num) -> {
        
                return num % 2 == 0;
            });
            num1.stream().forEach(System.out::println);
        }
        public List<Integer> getNum(List<Integer> list, Predicate<Integer> predicate){
        
            ArrayList<Integer> integers = new ArrayList<>();
            for (Integer i : list) {
        
                if (predicate.test(i)){
        
                    integers.add(i);
                }
            }
            return integers;
        }

执行结果：  
![在这里插入图片描述][90567dc18b0f4c52ad8f48ce6522d52a.png]

## 四、方法引用与构造引用 ##

> 方法引用和构造引用是为了进一步的简化代码

### 1、方法引用 ###

> 当传递给Lambda体的操作已经有实现的方法的时候，可以使用方法引用  
> 实现抽象方法的参数列表必须与引用方法的参数列表一致  
> 方法引用的语法格式： 使用操作符“ **::** ”将方法名和类或者对象的名字分隔开来

使用方法引用的情况有以下三种

*  对象 :: 实例方法
 *  类 :: 静态方法
 *  类 :: 实例方法  
    ![在这里插入图片描述][de2c0f41107e4a02b2223e77af5d4175.png]

### 2、构造引用 ###

![在这里插入图片描述][4cc609ebad904311b5fc9cd6a4608380.png]

## 总结 ##

Lambda表达式是JDK1.8的新特性，掌握了它可以节省我们的开发时间，减少代码量，但是可读性会变差。需要特别注意的是  
Lambda表达式是语法糖，只是会让开发人员减少代码的书写，并不会提高运行效率  
Lambda表达式本质上是接口的实例对象

[3538a82643dc4562b144d6e3fb85a02e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/34097a12beaf44488e6cfb2aa5bf9eb5.png
[2f1c2538115e4fffa6690fa2b46c5d0f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/42acd25bf5ec4a77af01427c3f6e71ba.png
[ece0a6c57985425bb3261366b7270b72.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/5f46ac6ff1f240609157508b2638c443.png
[4ffb73ebbd6849e0bda1238f4a82f8c7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/c2cc2d759f714819ba619f111015dfdd.png
[a4c221ae62b14be896ad2f5003150de4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/92e866b509d048ef8cba3752400ce3bf.png
[90567dc18b0f4c52ad8f48ce6522d52a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/27e24ff43b0f49b483c3eb38eb3c9e41.png
[de2c0f41107e4a02b2223e77af5d4175.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/2251c9d60ced46eba6679258091e966e.png
[4cc609ebad904311b5fc9cd6a4608380.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/6f4ddf695c364412bdc47c5294477793.png