Java 8 - Lambda从兴趣盎然到索然无味

╰半夏微凉° 2022-11-06 00:50 151阅读 0赞

### 文章目录 ###

*  Pre
 *  常见的内置函数式接口
 *   *  函数型接口
     *  消费型接口
     *  供给型接口
     *  断言型接口
 *  基本用法
 *   *  无参
     *  1个参数
     *  多个参数
 *  方法引用
 *   *  引用静态方法
     *  引用对象的方法
     *  引用类的方法
     *  引用构造方法

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70]

# Pre #

Lambda表达式是以函数式接口作为基础，所以非常有必要了解一下函数式接口

[Java 8 - 01 优雅编程 lambda 以及 @FunctionalInterface注解一点通][Java 8 - 01 _ lambda _ _FunctionalInterface]

[Java 8 - 02 Lambda Expression][]

[Java 8 - 03 Lambda 函数式接口Predicate & Consumer & Function & Supplier][Java 8 - 03 Lambda _Predicate _ Consumer _ Function _ Supplier]

[Java 8 - 04 类型检查、类型推断以及限制][Java 8 - 04]

[Java 8 - 05 方法引用][Java 8 - 05]

[Java 8 - 06 Lambda 和方法引用实战][Java 8 - 06 Lambda]

[Java 8 - 07 复合 Lambda 表达式][Java 8 - 07 _ Lambda]

![在这里插入图片描述][20210307092146152.gif_pic_center]

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

# 常见的内置函数式接口 #

这里我们简单点得再来梳理一下

## 函数型接口 ##

Function<T,R>

抽象方法： R apply(T t)，传入一个参数，返回想要的结果。

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

## 消费型接口 ##

Consumer<T>

抽象方法： void accept(T t)，接收一个参数进行消费，但无需返回结果。

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

## 供给型接口 ##

Supplier<T>

抽象方法：T get()，无参数，有返回值。

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

## 断言型接口 ##

Predicate<T>

抽象方法： boolean test(T t),传入一个参数，返回一个布尔值。

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

# 基本用法 #

Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。使用 Lambda 表达式可以使代码变的更加简洁紧凑。

语法如下

(parameters) -> expression

或

(parameters) ->{  statements; }

*  可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
 *  可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
 *  可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
 *  可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

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

## 无参 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 1]

/** * 无参的形式 */
    
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    System.out.println("artisan learn lambda");
                }
            }).start();
    
            /** * () -> { * 执行语句; * } * * 如果 执行的内容仅有一句，{} 也是可以省略的。 执行语句后无标点符号 * * () -> * */
            new Thread(()->System.out.println("artisan learn lambda")).start();

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

## 1个参数 ##

([类名]  变量名) -> { 
    	执行语句;
    }

类名可选， lambda会通过类型推导自动推到出类型 。

当只有一条语句时，依然可以对代码块进行简写

([类名 ]变量名) -> 表达式

或者

变量名 -> 表达式

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

## 多个参数 ##

多参函数是指具有两个及以上参数的函数

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 2]

([类名1 ]变量名1, [类名2 ]变量名2[, ...]) -> { 
    
    	执行语句
    
    }

举个例子

List<Integer> list = Arrays.asList(1, 2, 3);
    
            Collections.sort(list, new Comparator<Integer>() { 
                @Override
                public int compare(Integer o1, Integer o2) { 
                    return o1.compareTo(o2);
                }
            });

上面是原始的写法哈，大家都很熟悉

怎么使用lambda简写呢？

Collections.sort(list, (o1,o2) -> { 
                return o1.compareTo(o2);
            });

还能更简洁

当只有一条语句时，还可以对代码块进行简写，格式如下：

([类名1 ]变量名1, [类名2 ]变量名2[, ...]) -> 表达式

Collections.sort(list, (o1,o2) -> o1.compareTo(o2));

此时类名也是可以省略的，但括号不能省略。如果这条语句需要返回值，那么 return 关键字是不需要写的。

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

其实还能更精简，如下形式

Collections.sort(list, Integer::compareTo);

咦 ，这是什么？ ------------> 方法引用  
![在这里插入图片描述][20210307102748378.gif_pic_center]

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

# 方法引用 #

是一种简化开发的语法糖。

在使用 Lambda 表达式的时候，如果“->”的右边要执行的表达式只是调用一个类已有的方法，那么就可以用「方法引用」来替代 Lambda 表达式。

方法引用可以分为 4 类：

*  引用静态方法
 *  引用对象的方法
 *  引用类的方法
 *  引用构造方法

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

## 引用静态方法 ##

当要执行的表达式是调用某个类的静态方法，并且这个静态方法的参数列表和接口里抽象函数的**参数列表一一对应**时，可以采用引用静态方法的格式。

假如 Lambda 表达式符合如下格式：

([变量1, 变量2, ...]) -> 类名.静态方法名([变量1, 变量2, ...])

可以简写成如下格式：

类名::静态方法名

注意:**静态方法名后面不需要加括号，也不用加参数**，通过类型推断可以推导出来。

来个demo

import java.util.Arrays;
    import java.util.Collections;
    
    /** * @author 小工匠 * @version 1.0 * @description: TODO * @date 2021/3/7 11:19 * @mark: show me the code , change the world */
    public class CompareUtil { 
    
    
        public static int compare(Integer o1,Integer o2){ 
            return o1.compareTo(o2);
        }
    
    
        public static void main(String[] args) { 
            // lambda 
            Collections.sort(Arrays.asList(1,2,3), (o1,o2)->CompareUtil.compare(o1,o2)).;
            
            // 采用方法引用 
            Collections.sort(Arrays.asList(1,2,3),CompareUtil::compare);
        }
    }

注意这里自定义的compare 函数的参数和 Comparable 接口的 compare 函数的参数是一一对应的。

所以一般的 Lambda 表达式可以这样写

// lambda 
       Collections.sort(Arrays.asList(1,2,3), (o1,o2)->CompareUtil.compare(o1,o2)).;

如果采用方法引用的方式，可以简写成这样  
阿萨德2·

Collections.sort(Arrays.asList(1,2,3),CompareUtil::compare);

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

## 引用对象的方法 ##

当要执行的表达式是调用某个对象的方法，并且这个方法的参数列表和接口里抽象函数的参数列表一一对应时，就可以采用引用对象的方法的格式。

假如 Lambda 表达式符合如下格式：

([变量1, 变量2, ...]) -> 对象引用.方法名([变量1, 变量2, ...])

可以简写成如下格式：

对象引用::方法名

来个demo

public class CompareUtil { 
    
    
        public  int compareNoramMethod(Integer o1,Integer o2){ 
            return o1.compareTo(o2);
        }
    
        public static void main(String[] args) { 
    
            // 实例化对象
            CompareUtil compare = new CompareUtil();
    
            // 传统的lambda
            Collections.sort(Arrays.asList(1,2,3),(o1,o2)->compare.compareNoramMethod(o1,o2));
    
            // 方法引用
            Collections.sort(Arrays.asList(1,2,3),compare::compareNoramMethod);
            
        }
    }

当创建一个该类的对象，并在 Lambda 表达式中使用该对象的方法时，通常可以这么写：

// 实例化对象
     CompareUtil compare = new CompareUtil();
     // 传统的lambda
     Collections.sort(Arrays.asList(1,2,3),(o1,o2)->compare.compareNoramMethod(o1,o2));

注意这里函数的参数也是一一对应的，那么采用方法引用的方式，可以这样简写：

// 实例化对象
      CompareUtil compare = new CompareUtil();
       // 方法引用
      Collections.sort(Arrays.asList(1,2,3),compare::compareNoramMethod);

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

当要执行的表达式是调用 Lambda 表达式所在的类的方法时，还可以采用如下格式：

this::方法名

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 3]

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

## 引用类的方法 ##

引用类的方法所采用的参数对应形式与上两种有点区别

如果 Lambda 表达式的“->”的右边要执行的表达式是调用的“->”的左边第一个参数的某个实例方法，并且从第二个参数开始（或无参）对应到该实例方法的参数列表时，就可以使用这种方法。

(变量1[, 变量2, ...]) -> 变量1.实例方法([变量2, ...])

可以简化为

变量1对应的类名::实例方法名

来个demo

Collections.sort(Arrays.asList(1,2,3), (o1, o2) -> o1.compareTo(o2));
            
     Collections.sort(Arrays.asList(1,2,3),Integer::compareTo);

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

## 引用构造方法 ##

当要执行的表达式是新建一个对象，并且这个对象的构造方法的参数列表和接口里函数的参数列表一一对应时，就可以采用「引用构造方法」的格式。

假如我们的 Lambda 表达式符合如下格式：

([变量1, 变量2, ...]) -> new 类名([变量1, 变量2, ...])

就可以简写成如下格式：

类名::new

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70]: /images/20221023/d6f4980f83e54762aadffa779f65fb38.png
[Java 8 - 01 _ lambda _ _FunctionalInterface]: https://artisan.blog.csdn.net/article/details/106042948
[Java 8 - 02 Lambda Expression]: https://artisan.blog.csdn.net/article/details/106065157
[Java 8 - 03 Lambda _Predicate _ Consumer _ Function _ Supplier]: https://artisan.blog.csdn.net/article/details/106153801
[Java 8 - 04]: https://artisan.blog.csdn.net/article/details/106167115
[Java 8 - 05]: https://artisan.blog.csdn.net/article/details/106169504
[Java 8 - 06 Lambda]: https://artisan.blog.csdn.net/article/details/106182816
[Java 8 - 07 _ Lambda]: https://artisan.blog.csdn.net/article/details/106183741
[20210307092146152.gif_pic_center]: /images/20221023/20e01e3a4d67410fad735de42aa4eb29.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 1]: /images/20221023/19182eb9ebc34f799e876c0ef7406418.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 2]: /images/20221023/d69d564ea8b04755a074e1ec2b8da6a8.png
[20210307102748378.gif_pic_center]: /images/20221023/d94660ae51cf4eb4ac21c469422b8212.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 3]: /images/20221023/bc010c94273940b1bc797a808df53566.png