Java——Lambda表达式

Yuan_o_2024-06-27 13:56

1. 背景

Lambda表达式是JavaSE 8中一个重要的新特性。Lambda表达式允许你通过表达式来代替功能接口。 Lambda表达式就和方法一样，它提供了一个正常的参数列表和一个使用这些参数的主体(body，可以是一个表达式或一个代码块)。 Lambda 表达式（Lambda expression），基于数学中的 λ演算得名，也可称为闭包(Closure)。

1.1 Lambda表达式的语法

基本语法: (parameters) -> expression 或 (parameters) ->{ statements; }

Lambda表达式由三部分组成：

  1. paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。

2.->：可理解为"被用于"的意思

  1. 方法体：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不返回，这里的代码块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不返回。
java 复制代码 
        // 1. 不需要参数,返回值为 2
        () -> 2
        // 2. 接收一个参数(数字类型),返回其2倍的值
        x -> 2 * x
        // 3. 接受2个参数(数字),并返回他们的和
        (x, y) -> x + y
        // 4. 接收2个int型整数,返回他们的乘积
        (int x, int y) -> x * y
        // 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
        (String s) -> System.out.print(s)

1.2 函数式接口

要了解Lambda表达式，首先需要了解什么是函数式接口，函数式接口定义：一个接口有且只有一个抽象方法。

注意：

  1. 如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口
  2. 如果我们在某个接口上声明了 @FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求该接 口，这样如果有两个抽象方法，程序编译就会报错的。所以，从某种意义上来说，只要你保证你的接口中只有一个抽象方法，你可以不加这个注解。加上就会自动进行检测。

定义方式：

java 复制代码 
        @FunctionalInterface
        interface NoParameterNoReturn {
            //注意：只能有一个方法
            void test();
        }

特例：

java 复制代码 
        @FunctionalInterface
        interface NoParameterNoReturn {
            void test();
            default void test2() {
                System.out.println("JDK1.8新特性，default默认方法可以有具体的实现");
            }
        }

2. Lambda表达式的基本使用

准备几个接口：

java 复制代码 
//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
    void test();
}
//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
    void test(int a);
}
//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
    void test(int a,int b);
}
//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}
//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
    int test(int a);
}
//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
    int test(int a,int b);
}

Lambda可以理解为：Lambda就是匿名内部类的简化，实际上是创建了一个类，实现了接口，重写了接口的方法。没有使用Lambda表达式的时候的调用方式：

java 复制代码 
NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn(){
    @Override
    public void test() {
        System.out.println("hello");
    }
};
noParameterNoReturn.test();

使用Lambda表达式：

java 复制代码 
public class TestDemo {
    public static void main(String[] args) {
        NoParameterNoReturn noParameterNoReturn = ()->System.out.println("无参数无返回值");
        noParameterNoReturn.test();

        OneParameterNoReturn oneParameterNoReturn = (int a)->System.out.println("一个参数无返回值："+ a);
        oneParameterNoReturn.test(10);

        MoreParameterNoReturn moreParameterNoReturn = (int a,int b)->System.out.println("多个参数无返回值："+a+" "+b);
        moreParameterNoReturn.test(20,30);

        //有返回值无参数！
        NoParameterReturn noParameterReturn = ()->10;
        System.out.println(noParameterReturn.test());

        //有返回值有一个参数！
        OneParameterReturn oneParameterReturn = a->a;
        oneParameterReturn.test(50);
        
        //有返回值多个参数！
        MoreParameterReturn moreParameterReturn = (a,b)->a+b;
        System.out.println(moreParameterReturn.test(60, 70));
    }
}

语法精简tips：

  1. 参数类型可以省略，如果需要省略，每个参数的类型都要省略
  2. 参数的小括号里面只有一个参数，那么小括号可以省略
  3. 如果方法体当中只有一句代码，那么大括号可以省略
  4. 如果方法体中只有一条语句，且是return语句，那么大括号可以省略，且去掉return关键字

3. 变量捕获

3.1 匿名内部类的变量捕获

java 复制代码 
class Test {
    public void func(){
        System.out.println("func()");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        int a = 100;
        new Test(){
            @Override
            public void func() {
                System.out.println("我是内部类，且重写了func这个方法！");
                System.out.println("我是捕获到变量 a == "+a
                        +" 我是一个常量，或者是一个没有改变过值的变量！");
            }
        };
    }
}

在上述代码当中的变量a就是，捕获的变量。这个变量要么是被final修饰，如果不是被final修饰的 你要保证在使用 之前，没有修改。如下代码就是错误的代码：

3.2 Lambda的变量捕获

4. Lambda在集合中的使用

为了能够让Lambda和Java的集合类集更好的一起使用，集合当中也新增了部分接口，以便与Lambda表达式对接。

|------------|-------------------------------------------------------------------------------------------------------------------------------|
| 对应的接口 | 新增的方法 |
| Collection | removeIf() spliterator() stream() parallelStream() forEach() |
| List | replaceAll() sort() |
| Map | getOrDefault() forEach() replaceAll() putIfAbsent() remove() replace() computeIfAbsent() computeIfPresent() compute() merge() |

4.1 Collection接口

forEach()方法演示

该方法在接口 Iterable 当中，原型如下：

java 复制代码 
default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}

该方法表示：对容器中的每个元素执行action指定的动作

java 复制代码 
public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("Hello");
    list.add("world");
    list.add("hello");
    list.add("lambda");
    list.forEach(new Consumer<String>(){
        @Override
        public void accept(String str){
            //简单遍历集合中的元素。
            System.out.print(str+" ");
        }
    });
}

输出结果：Hello world hello lambda

我们可以修改为如下代码：

java 复制代码 
public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("Hello");
    list.add("bit");
    list.add("hello");
    list.add("lambda");
    //表示调用一个，不带有参数的方法，其执行花括号内的语句，为原来的函数体内容。
    list.forEach(s -> {
        System.out.println(s);
    });
}

输出结果：Hello world hello lambda

4.2 List接口

sort()方法的演示

sort方法源码：该方法根据c指定的比较规则对容器元素进行排序

java 复制代码 
public void sort(Comparator<? super E> c) {
    final int expectedModCount = modCount;
    Arrays.sort((E[]) elementData, 0, size, c);
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
    modCount++;
}

使用示例：

java 复制代码 
public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("Hello");
    list.add("world");
    list.add("hello");
    list.add("lambda");
    list.sort(new Comparator<String>() {
        @Override
        public int compare(String str1, String str2){
            //注意这里比较长度
            return str1.length()-str2.length();
        }
    });
    System.out.println(list);
}

输出结果：Hello, world, hello, lambda

修改为Lambda表达式：

java 复制代码 
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("world");
        list.add("hello");
        list.add("lambda");
//调用带有2个参数的方法，且返回长度的差值
        list.sort((str1,str2)-> str1.length()-str2.length());
        System.out.println(list);
    }

输出结果：Hello, world, hello, lambda

4.3 Map接口

HashMap 的 forEach()

该方法原型如下：

java 复制代码 
default void forEach(BiConsumer<? super K, ? super V> action) {
    Objects.requireNonNull(action);
    for (Map.Entry<K, V> entry : entrySet()) {
        K k;
        V v;
        try {
            k = entry.getKey();
            v = entry.getValue();
        } catch(IllegalStateException ise) {
            // this usually means the entry is no longer in the map.
            throw new ConcurrentModificationException(ise);
        }
        action.accept(k, v);
    }
}

作用是对Map中的每个映射执行action指定的操作。

代码示例：

java 复制代码 
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "hello");
        map.put(2, "world");
        map.put(3, "hello");
        map.put(4, "lambda");
        map.forEach(new BiConsumer<Integer, String>(){
            @Override
            public void accept(Integer k, String v){
                System.out.print(k + "=" + v + " ");
            }
        });
    }

输出结果： 1=hello 2=world 3=hello 4=lambda

使用lambda表达式后的代码：

java 复制代码 
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "hello");
        map.put(2, "world");
        map.put(3, "hello");
        map.put(4, "lambda");
        map.forEach((k,v)-> System.out.print(k + "=" + v + " "));
    }

输出结果：1=hello 2=world 3=hello 4=lambda

5. 总结

Lambda表达式的优点很明显，在代码层次上来说，使代码变得非常的简洁。缺点也很明显，代码不易读。

优点：

    1. 代码简洁，开发迅速
    1. 方便函数式编程
    1. 非常容易进行并行计算
    1. Java 引入 Lambda，改善了集合操作

缺点：

    1. 代码可读性变差
    1. 在非并行计算中，很多计算未必有传统的 for 性能要高
    1. 不容易进行调试
相关推荐
Q_19284999063 分钟前
基于Spring Boot的九州美食城商户一体化系统
java·spring boot·后端
张国荣家的弟弟21 分钟前
【Yonghong 企业日常问题 06】上传的文件不在白名单，修改allow.jar.digest属性添加允许上传的文件SH256值？
java·jar·bi
ZSYP-S32 分钟前
Day 15：Spring 框架基础
java·开发语言·数据结构·后端·spring
yuanbenshidiaos35 分钟前
c++------------------函数
开发语言·c++
yuanbenshidiaos39 分钟前
C++----------函数的调用机制
java·c++·算法
唐叔在学习43 分钟前
【唐叔学算法】第21天：超越比较-计数排序、桶排序与基数排序的Java实践及性能剖析
数据结构·算法·排序算法
程序员_三木1 小时前
Three.js入门-Raycaster鼠标拾取详解与应用
开发语言·javascript·计算机外设·webgl·three.js
是小崔啊1 小时前
开源轮子 - EasyExcel01(核心api)
java·开发语言·开源·excel·阿里巴巴
ALISHENGYA1 小时前
全国青少年信息学奥林匹克竞赛（信奥赛）备考实战之分支结构（switch语句）
数据结构·算法
tianmu_sama1 小时前
[Effective C++]条款38-39 复合和private继承
开发语言·c++
热门推荐
01构建高效的广告投放系统：应用架构的设计与实现02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04Cube-Studio：开源大模型全链路一站式中台05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问07〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO