【JDK新特性】一篇搞懂Lambda表达式 & 函数式接口

头像
即兴小索奇
     河南
    阅读 7 分钟
    头图

    【必看】原创声明：转载请注明作者 & 文章来源搞定了Lambda

    hello，我是小索奇

    你问：JDK新特性（包含Lambda表达式 & 函数式接口 ）要学吗？

    我答：当然要学了，如果你以后敲代码的话，你一定会用到 and 见到，现在学会的话，将来的你一定会感谢现在的你~

    用起来你会发现，哇真的好用！在后期学习框架时你也一定会遇到

    代码比较枯燥，现在不想看的可收藏备看~

    概述

    Lambda是JDK8的语法糖。它可以对某些匿名内部类的写法进行简化，它是函数式编程的一个重要体现。让我们不用关注什么是对象，重点关注我们对数据做了什么操作，可以说它Lambda表达式就是一个对象

    • Lambda表达式在C++、C#、Python、Scala等一些语言中也支持，Java支持的还算比较晚的（确实好用）
    • Lambda关注的是方法的参数（）,还有具体做了什么{}方法体，中间用-> ，凡是确定的东西都可删除（比如一个内部类，直接确定是它）

    基本语法

    (参数列表)->{代码}

    拓展__匿名内部类

    • Runnable是一个接口
    • Runnable只有一个抽象方法

    image-20230717000509143

    LambdaTest代码演示

    public class LambdaTest {

    @Test
    public void test1(){
// Runnable只有一个抽象方法
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("我爱即兴小索奇");
            }
        };
        r1.run();

        System.out.println("***********************");

        //Lambda表达式
        Runnable r2 = () -> {
                System.out.println("我是即兴小索奇");
        };

        r2.run();

    }
    @Test
    public void test2(){

        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };

        int compare1 = com1.compare(12,21);
        System.out.println(compare1);

        System.out.println("***********************");
        
        //Lambda表达式的写法,箭头后的{}是可以省略的，参数类型确定也可以省略
        
        Comparator<Integer> com2 =  (Integer o1, Integer o2) -> Integer.compare(o1,o2);
        //  Comparator<Integer> com2 =  (o1, o2) -> Integer.compare(o1,o2);
        int compare2 = com2.compare(23,21);
        System.out.println(compare2);

        System.out.println("***********************");
        //方法引用
        Comparator<Integer> com3 = Integer :: compare;
        int compare3 = com3.compare(23,21);
        System.out.println(compare3);
    }
}

    LambdaTest01细节演示

    public class LambdaTest1 {
    //语法格式一：无参，无返回值
    @Test
    public void test1(){
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("我是即兴小索奇");
            }
        };

        r1.run();

        System.out.println("***********************");
        Runnable r2 = () -> {
            System.out.println("即兴小索奇运行了");
        };

        r2.run();


    }
    //语法格式二：Lambda 需要一个参数，但是没有返回值。
    @Test
    public void test2(){

        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("小索奇在摸鱼！");

        System.out.println("*******************");

        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };

        con1.accept("小索奇正在打怪中...");

    }

    //语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
    @Test
    public void test3(){

        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("小索奇正在探索中...");

        System.out.println("*******************");
        Consumer<String> con2 = (s) -> {
            System.out.println(s);
        };
        con1.accept("小索奇正在探索中...");

    }


    @Test
    public void test3_1(){
        int[] arr = {1,2,3,4}; //类型推断

        HashMap<String,Integer> map = new HashMap<>();//类型推断

        var entrySet = map.entrySet(); //类型推断 ,在jdk10及之后可以用,现持续存在

    }


    //语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略
    @Test
    public void test4(){
        Consumer<String> con1 = (s) -> {
            System.out.println(s);
        };
        con1.accept("小索奇正在探索中...");

        System.out.println("*******************");

        Consumer<String> con2 = s -> {
            System.out.println(s);
        };
        con2.accept("小索奇正在睡觉...");


    }

    //语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
    @Test
    public void test5(){

        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        };

        System.out.println(com1.compare(12,21));

        System.out.println("*****************************");

        Comparator<Integer> com2 = (o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };

        System.out.println(com2.compare(12,21));
    }

    //语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略
    @Test
    public void test6(){

        Comparator<Integer> com1 = (o1,o2) -> {
            return o1.compareTo(o2);
        };

        System.out.println(com1.compare(12,6));

        System.out.println("*****************************");

        Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);

        System.out.println(com2.compare(12,16));
    }

    @Test
    public void test7(){
        Consumer<String> con1 = s -> {
            System.out.println(s);
        };
        con1.accept("小索奇正在睡大街...");

        System.out.println("*****************************");
    }
}

    自定义函数式接口

    @FunctionalInterface
public interface MyFunctionalInterface {
    void method();

//    void method1();
}

public class MyFunctionalInterfaceTest {
    @Test
    public void test1(){
        MyFunctionalInterface m = () -> System.out.println("hello");

        m.method();
    }
}

    总结

    直达 java.util.function文档：https://docs.oracle.com/en/java/javase/17/docs/api/java.base/...

    1. Lambda表达式的使用举例：

    (o1, o2) -> Integer.compare(o1,o2);

    1. Lambda表达式的格式举例:

    lambda形参列表 -> lambda体

    1. Lambda表达式的格式
    • lambda操作符或箭头操作符
    • -> 的左边: lambda形参列表，对应着要重写的接口中的抽象方法的形参列表。
    • -> 的右边: lambda体，对应着接口的实现类要重写的方法的方法体。
    1. Lambda表达式的本质：

    • 一方面，lambda表达式作为接口的实现类的对象。 --->说白了Lambda表达式就是对象， "万事万物皆对象"

      另一方面，lambda表达式是一个匿名函数。

    1. 函数式接口
    什么是函数式接口？为什么需要函数式接口？
    • 如果接口中只声明有一个抽象方法，则此接口就称为函数式接口（如Runnable就是函数式接口 ，底层加上了@FunctionalInterface注解，可以校验它是一个函数式接口，加了最多就只能写一个抽象方法了）
    • 因为只有给函数式接口提供实现类的对象时，我们才可以使用lambda表达式。
    api中函数式接口所在的包
    • jdk8中声明的函数式接口都在java.util.function包下。
    4个基本的函数式接口

    ​ 接口 对应的抽象方法

    • 消费型接口：Consumer<T> void accept(T t)

      消费型接口表示接收一个参数并执行某些操作，但没有返回值。它常用于需要执行一些操作但不需要返回结果的场景，例如遍历集合、修改对象状态等，例如

      Consumer<String> consumer = s -> System.out.println(s);
consumer.accept("hello world");

    • 供给型接口：Supplier<T> T get()

      供给型接口表示不需要接收任何参数，但需要返回一个结果。它常用于需要生成某些数据的场景，例如生成随机数、获取当前时间等，例如

      Supplier<Integer> supplier = () -> (int) (Math.random() * 100);
System.out.println(supplier.get());

    • 函数型接口：Function<T,R> R apply(T t)

      函数型接口表示接收一个参数并返回一个结果。它常用于需要对某些数据进行处理并返回结果的场景，例如字符串转换、数据加工等。例如：

      Function<String, Integer> function = s -> s.length();
System.out.println(function.apply("hello world"));

    • 判断型接口：Predicate<T> boolean test(T t)

      判断型接口表示接收一个参数并返回一个布尔值。它常用于需要对某些数据进行判断并返回布尔值的场景，例如过滤集合、判断对象状态等，例如

      Predicate<Integer> predicate = i -> i > 0;
System.out.println(predicate.test(-1));
    1. Lambda表达式的语法规则总结
    • -> 的左边：lambda形参列表，参数的类型都可以省略。如果形参只有一个，则一对()也可以省略。

    • -> 的右边：lambda体，对应着重写的方法的方法体。如果方法体中只有一行执行语句，则一对{}可以省略。

      如果有return关键字，则必须一并省略。

    java
    即兴小索奇
    1 声望0 粉丝
    « 上一篇
    【Java】刷题啦
    下一篇 »
    【JDK新特性】StreamAPI 必学！

    引用和评论

    推荐阅读
    头像
    【JDK新特性】StreamAPI 必学！

    即兴小索奇阅读 549

    头像
    Bitmap 和 布隆过滤器傻傻分不清？你这不应该啊

    程序员小富赞 10阅读 4.8k评论 1

    头像
    Jerry和您聊聊Chrome开发者工具

    注销赞 9阅读 4.9k评论 3

    头像
    Spring 实现 3 种异步流式接口，干掉接口超时烦恼

    程序员小富赞 6阅读 2.5k

    头像
    💢线上高延迟请求排查

    crossoverJie赞 6阅读 4k评论 5

    头像
    这些年

    注销赞 2阅读 4.1k

    头像
    一文讲清楚static关键字

    seven97_top赞 4阅读 634

    0 条评论
    得票最新