lambda表达式_Lambda表达式原理

最新推荐文章于 2024-03-28 03:39:24 发布
最新推荐文章于 2024-03-28 03:39:24 发布
阅读量194 收藏
点赞数
文章标签： lambda表达式

f845b7be31563bb2919cc51ab3c3fa40.png

一、前言

  • java8中，Lambda表达式是匿名函数的一种语法糖，简化了匿名内部类的冗杂代码
  • java8中，每一个Lambda表达式必须有一个函数式接口与之对应

二、语法

9f136a3812456429852150cb13065441.png

三、使用举例

前置：函数式接口

//数学操作
@FunctionalInterface
public interface MathOperation {
    int operation(int a, int b);
    //默认实现
    default int addition(int a, int b) {
        return a + b;
    }
}
  • 声明参数类型
MathOperation addition = (int a, int b) -> a + b;
  • 不声明参数类型 java MathOperation subtraction = (a, b) -> a - b;
  • 返回语句块
MathOperation multiplication = (a, b) -> {
            System.out.println("this is multiplication");
            return a * b;
        };
  • 配合Predicate
//筛选符合predicate的值
private static void filter(List<Integer> list, Predicate<Integer> predicate) {
    for (Integer n : list) {
        if (predicate.apply(n)) {
            System.out.print(n + " ");
        }
    }
}
//筛选出1到5之间的偶数
filter(ImmutableList.of(1, 2, 3, 4, 5), (n) -> n != null && n % 2 == 0)
//输出：2 4

四、注意事项：

  • 不能在lambda内部修改定义在域外的变量，可以读取
int a = 0;
    new Thread(
           () -> a++
           //Variable used in lambda expression should be final or effectively final
    ).start();
  • 当代码体不修改Lambda表达式提供的参数时候，代码体可以替换为方法引用，如果修改参数的时候只能使用Lambda表达式
List<String> aList = ImmutableList.of("1", "2", "3");
    aList.forEach(string -> System.out.println(string));
    aList.forEach(System.out::println);//可以使用方法引用
    aList.forEach(string -> System.out.println("value:" + string))//只能使用Lambda表达式

五、原理介绍

1、测试源码

public class LambdaTest1 {
    public static void main(String[] args) {
        new Thread(
                () -> System.out.println("this is lambda")
        );
    }
}

2、反编译字节码私有成员

结果如下：

public class com.xin.lambda.LambdaTest1 {
  public com.xin.lambda.LambdaTest1();
  public static void main(java.lang.String[]);
  private static void lambda$main$0();
}

从反编译结果中可以看到，测试类中增加了一个私有静态方法lambda$main$0()。这一私有静态方法提供给main方法调用，这种实现方式和匿名内部类差别较大，后者编译后生成两个class文件。

3、查看更详细的字节码信息

Classfile /C:/Users/69040/Desktop/LambdaTest1.class
  Last modified 2018-8-23; size 1184 bytes
  MD5 checksum ea1e2b1d14787a49549f6984174f1b37
  Compiled from "LambdaTest1.java"
public class com.xin.lambda.LambdaTest1
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #9.#24         // java/lang/Object."<init>":()V
   #2 = Class              #25            // java/lang/Thread
   #3 = InvokeDynamic      #0:#30         // #0:run:()Ljava/lang/Runnable;
   #4 = Methodref          #2.#31         // java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
   #5 = Fieldref           #32.#33        // java/lang/System.out:Ljava/io/PrintStream;
   #6 = String             #34            // this is lambda
   #7 = Methodref          #35.#36        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #8 = Class              #37            // com/xin/lambda/LambdaTest1
   #9 = Class              #38            // java/lang/Object
  #10 = Utf8               <init>
  #11 = Utf8               ()V
  #12 = Utf8               Code
  #13 = Utf8               LineNumberTable
  #14 = Utf8               LocalVariableTable
  #15 = Utf8               this
  #16 = Utf8               Lcom/xin/lambda/LambdaTest1;
  #17 = Utf8               main
  #18 = Utf8               ([Ljava/lang/String;)V
  #19 = Utf8               args
  #20 = Utf8               [Ljava/lang/String;
  #21 = Utf8               lambda$main$0
  #22 = Utf8               SourceFile
  #23 = Utf8               LambdaTest1.java
  #24 = NameAndType        #10:#11        // "<init>":()V
  #25 = Utf8               java/lang/Thread
  #26 = Utf8               BootstrapMethods
  #27 = MethodHandle       #6:#39         // invokestatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
  #28 = MethodType         #11            //  ()V
  #29 = MethodHandle       #6:#40         // invokestatic com/xin/lambda/LambdaTest1.lambda$main$0:()V
  #30 = NameAndType        #41:#42        // run:()Ljava/lang/Runnable;
  #31 = NameAndType        #10:#43        // "<init>":(Ljava/lang/Runnable;)V
  #32 = Class              #44            // java/lang/System
  #33 = NameAndType        #45:#46        // out:Ljava/io/PrintStream;
  #34 = Utf8               this is lambda
  #35 = Class              #47            // java/io/PrintStream
  #36 = NameAndType        #48:#49        // println:(Ljava/lang/String;)V
  #37 = Utf8               com/xin/lambda/LambdaTest1
  #38 = Utf8               java/lang/Object
  #39 = Methodref          #50.#51        // java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
  #40 = Methodref          #8.#52         // com/xin/lambda/LambdaTest1.lambda$main$0:()V
  #41 = Utf8               run
  #42 = Utf8               ()Ljava/lang/Runnable;
  #43 = Utf8               (Ljava/lang/Runnable;)V
  #44 = Utf8               java/lang/System
  #45 = Utf8               out
  #46 = Utf8               Ljava/io/PrintStream;
  #47 = Utf8               java/io/PrintStream
  #48 = Utf8               println
  #49 = Utf8               (Ljava/lang/String;)V
  #50 = Class              #53            // java/lang/invoke/LambdaMetafactory
  #51 = NameAndType        #54:#58        // metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
  #52 = NameAndType        #21:#11        // lambda$main$0:()V
  #53 = Utf8               java/lang/invoke/LambdaMetafactory
  #54 = Utf8               metafactory
  #55 = Class              #60            // java/lang/invoke/MethodHandles$Lookup
  #56 = Utf8               Lookup
  #57 = Utf8               InnerClasses
  #58 = Utf8               (Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
  #59 = Class              #61            // java/lang/invoke/MethodHandles
  #60 = Utf8               java/lang/invoke/MethodHandles$Lookup
  #61 = Utf8               java/lang/invoke/MethodHandles
{
  public com.xin.lambda.LambdaTest1();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 11: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/xin/lambda/LambdaTest1;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=3, locals=1, args_size=1
         0: new           #2                  // class java/lang/Thread
         3: dup
         4: invokedynamic #3,  0              // InvokeDynamic #0:run:()Ljava/lang/Runnable;
         9: invokespecial #4                  // Method java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
        12: pop
        13: return
      LineNumberTable:
        line 13: 0
        line 16: 13
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      14     0  args   [Ljava/lang/String;
}
SourceFile: "LambdaTest1.java"
InnerClasses:
     public static final #56= #55 of #59; //Lookup=class java/lang/invoke/MethodHandles$Lookup of class java/lang/invoke/MethodHandles
BootstrapMethods:
  0: #27 invokestatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
    Method arguments:
      #28 ()V
      #29 invokestatic com/xin/lambda/LambdaTest1.lambda$main$0:()V
      #28 ()V
  • 代码中使用Lambda表达式的语句被编译成“ 4: invokedynamic #3, 0”，指向常量池#3位置
  • invokedynamic在JVM规范中有如下规定
1、操作码：
invokedynamic = 186 (0xba)
2、参数：
indexbyte1 indexbyte2 0 0,前两个参数构造索引（(indexbyte1 << 8) | indexbyte2），后两个参数必须为0。（the unsigned indexbyte1 and indexbyte2 are used to construct an index into the run-time constant pool of the current class (§2.6), where the value of the index is (indexbyte1 << 8) | indexbyte2. The run-time constant pool item at that index must be a symbolic reference to a call site specifier (§5.1). The values of the third and fourth operand bytes must always be zero. ）
3、索引指向的常量池项的类型为CONSTANT_InvokeDynamic_info
  • CONSTANT_InvokeDynamic_info
1、定义：
    CONSTANT_InvokeDynamic_info {
    u1 tag;
    u2 bootstrap_method_attr_index;
    u2 name_and_type_index;
}
2、参数：
bootstrap_method_attr_index：索引bootstrap_methods
name_and_type_index：索引类常量池里的CONSTANT_NameAndType_info
本例中常量池#3为：" #3 = InvokeDynamic      #0:#30 "
    即
    bootstrap_method_attr_index为#0
    name_and_type_index为#30，其内容为"NameAndType        #41:#42",跟下去后可以得出结果，这里描述的是Lambda表达式需要调用的函数："java/lang/Runnable.run()"
3、JVM规定：
如果类常量池中存在CONSTANT_InvokeDynamic_info，那么必须有且仅有一个BootstrapMethods_attribute。（There must be exactly one BootstrapMethods attribute in the attributes table of a given ClassFile structure if the constant_pool table of the ClassFile structure has at least one CONSTANT_InvokeDynamic_info entry (§4.4.10). There can be no more than one BootstrapMethods attribute in the attributes table of a given ClassFile structure. ）在反编译文件末尾可以看到的确有且仅有一个BootstrapMethods。
4、作用：
在java7中引入，主要作用给invokedynamic指令制定启动方法
  • BootstrapMethods_attribute
1、定义：
BootstrapMethods_attribute {
    u2 attribute_name_index;
    u4 attribute_length;
    u2 num_bootstrap_methods;
    {   u2 bootstrap_method_ref;
        u2 num_bootstrap_arguments;
        u2 bootstrap_arguments[num_bootstrap_arguments];
    } bootstrap_methods[num_bootstrap_methods];
}
2、参数：
每一个BootstrapMethod都包含一个bootstrap_method_ref和n个bootstrap_arguments
本例中：
    bootstrap_method_ref指向常量池#27，值为“MethodHandle       #6:#39”，继续查看jvm规范，
MethodHandle含有两个参数reference_kind、reference_index，reference_kind值为6，意思是REF_invokeStatic，reference_index为39，即常量池#39位置，内容为“Methodref          #50.#51”，表明这里调用的是java/lang/invoke/LambdaMetafactory.metafactory()
  • metafactory函数 1、源码如下
public static CallSite metafactory(MethodHandles.Lookup caller,
                                       String invokedName,
                                       MethodType invokedType,
                                       MethodType samMethodType,
                                       MethodHandle implMethod,
                                       MethodType instantiatedMethodType)
            throws LambdaConversionException {
        AbstractValidatingLambdaMetafactory mf;
        mf = new InnerClassLambdaMetafactory(caller, invokedType,
                                             invokedName, samMethodType,
                                             implMethod, instantiatedMethodType,
                                             false, EMPTY_CLASS_ARRAY, EMPTY_MT_ARRAY);
        mf.validateMetafactoryArgs();
        return mf.buildCallSite();

2、参数： caller、invokedName、invokedType都由jvm生成，invokedName和invokedType分别是由动态调用点的NameAndType生成，samMethodType和instantiatedMethodType表示该函数式接口的方法描述符，implMethod最为重要，指用户实现的Lambda方法，本例为：com.xin.lambda.LambdaTest1.lambda$main$0()void/invokeStatic

3、代码快速解读：

metafactory()核心要生成CallSite，这个任务主要由InnerClassLambdaMetafactory的buildCallSite()完成，buildCallSite()继续调用spinInnerClass()函数，spinInnerClass函数用字节码工具在内存中生成一个类。

4、到此Lambda表达式的脱糖过程结束

六、结论

以上简单的分析了Lambda表达式的脱糖过程，还有很多细节需要各位大神去研究，总之，Lambda表达式的实现原理依然是基于内部类的方式。

lambda表达式实现原理分析
刘正阳的专栏
12-12 3415
本文将深入了解lambda表达式的实现原理和这样的实现方案的取舍权衡。 Java为什么需要lambda表达式？ 能够提升代码简洁性、提高代码可读性。 例如，在平时的开发过程中，把一个列表转换成另一个列表或map等等这样的转换操作是一种常见需求。 在没有lambda之前通常都是这样实现的。 List<Long> idList = Arrays.asList(1L, 2L, 3L); List<Person> personList = new Ar...
C++ 11，14，17中的 Lambda 表达式 _ Microsoft Docs[2].pdf
03-27
查Lambda表达式资料时很容易被函数闭包、Lambda演算、形式系统这些深奥名词淹没而放弃学习，其实Lambda表达式就是匿名函数（annoymous function）——允许我们使用一个函数，但不需要给这个函数起名字。还是有点难懂...
Lambda表达式原理简介
aidashi的专栏
03-26 1319
Lambda表达式原理简介 一、前言 java8中，Lambda表达式是匿名函数的一种语法糖，简化了匿名内部类的冗杂代码 java8中，每一个Lambda表达式必须有一个函数式接口与之对应 二、语法 参数列表 操作符 代码体(表达式/代码块) (int x,int y) -> x+y (x,y) -> x+y (int x,int y) -> ...
lambda表达式原理
qq_43517448的博客
04-17 2125
lambda表达式原理： ​ Lambda 表达式引用的局部变量必须是最终变量或实际上的最终变量，也就是说局部变量在被创建后不得被重新赋值。 ​ Lambda表达式是一个语法糖，会被编译生成为当前类的一个私有方法，Lambda表达式内直接引用局部变量本质是一种隐式传参，编译时会自动将引用的局部变量放到参数列表中（Lambda方法多了个参数），而引用的实例变量并不需要放到参数列表，因为方法内可以直接引用。 ​ 那么造成直接引用的局部变量需要final修饰的原因应该和这种隐式传参有关，所以这里需要再提一下
lambda表达式基本原理
Mr_PH的博客
09-05 1378
一般来说，任何lambda表达式都可以看做声明在函数式接口中的单个抽象方法的实现 1. lambda的使用需要 “函数式接口” 的支持 函数式接口：接口中只有一个抽象方法的接口，称为函数式接口， 函数式接口(Functional Interface)： 就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。 函数式接口可以被隐式转换为lambda表达式。 函数式接口可以现有的函...
Python GUI编程 170_lambda表达式_事件传参应用.mp4
02-09
Python GUI编程 170_lambda表达式_事件传参应用.mp4
18.【线程池、Lambda表达式】_java线程_lambda线程池_meantbs3_
10-03
Java线程池与Lambda表达式是Java开发中的两个重要概念，它们在提高程序效率和代码简洁性方面起着关键作用。 首先，让我们深入理解Java线程。在多核处理器时代，利用多线程能有效利用系统资源，提高程序并发执行的...
C++ 中lambda表达式的编译器实现原理
08-31
下面我们将详细探讨Lambda表达式的编译器实现原理。 首先，Lambda表达式的基本语法如下： ```cpp [capture_list] (parameter_list) -> return_type { function_body } ``` - `capture_list`：捕获列表，用于捕获...
C# lambda表达式原理定义及实例详解
08-18
C# lambda表达式原理定义及实例详解 今日，我们将详细探讨C# lambda表达式的原理定义及实例详解。lambda表达式是一个匿名函数，是一种高效的类似于函数式编程的表达式。它可以简化匿名委托的使用，减少开发中需要...
Lambda表达式从用到底层原理
weixin_52259848的博客
12-21 1456
Lambda表达式从用到底层原理
深入剖析Lambda表达式的底层实现原理
子牙老师
11-24 1595
hello，小伙伴们好，我是江湖人送外号[道格牙]的子牙老师。 又有一段时间没有给大家分享文章了，因为最近在筹备创办公司的事情，比较忙。今天偷得浮生半日闲，准备给大家分享下Lambda的底层实现。 如果想研究明白这个问题，我们需要研究哪些东西呢？干想也想不出来对吧，对着代码想吧。 对于这个问题，每个人的答案肯定不一样。但是，好的问题好的切入点是成功的一半。我给自己提了如下这些问题，然后顺着这些问题去研究，研究过程中对于JDK的有些设计或者代码实现不太理解，就尝试自己手写一遍，站在设计者的角度去思考，最终对
C++进阶(八) :Lambda 表达式及底层实现原理【详解】
王木木
12-29 7719
一、Lambda简介 lambda表达式是C++11中引入的一项新技术，利用lambda表达式可以编写内嵌的匿名函数，用以替换独立函数或者函数对象，并且使代码更可读。 Lambda 表达式完整的格式如下： [捕获列表] (形参列表) mutable 异常列表-> 返回类型 { 函数体 } 各项的含义： 捕获列表：捕获外部变量，捕获的变量可以在函数体中使用（可省略，即不捕获外部变量） []：默认不捕获任何变量； [=]：默认以值捕获所有变量； [&]：默认以引用捕
【c++新特性】lambda表达式原理剖析
青春不言败
03-17 271
一、基本概念 lambda表达式，c++11开始加进来的新特性。 二、语法讲解 三、代码实践
Lambda表达式实现原理
Weison
07-19 1604
Lambda表达式实现原理
Lambda表达式运行原理
Ason Blogs
07-27 540
目录一、创建测试样例二、利用Java命令编译分析三、文末 JDK8引入了Lambda表达式以后，对我们写代码提供了很大的便利，那么Lambda表达式是如何运用简单表示来达到运行效果的呢？今天，我们通过一个例子来学习下Lambda表达式的底层运行原理！ 一、创建测试样例 首先：我们创建一个测试类App.java，在它内部新建一个函数式接口Lam.java，只有一个抽象方法print()，作用是将传入的消息加工后再输出。 然后：我们在测试类App.java中进行lambda表达式的创建测试。 代码如下： pub
Lambda表达式，原理竟然是这
最新发布
2401_83947353的博客
03-28 865
大厂面试问深度，小厂面试问广度，如果有同学想进大厂深造一定要有一个方向精通的惊艳到面试官，还要平时遇到问题后思考一下问题的本质，找方法解决是一个方面，看到问题本质是另一个方面。还有大家一定要有目标，我在很久之前就想着以后一定要去大厂，然后默默努力，每天看一些大佬们的文章，总是觉得只有再学深入一点才有机会，所以才有恒心一直学下去。开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】转存中…(img-jvjzfUSH-1711568353320)]
lambda表达式的本质
wangpeng2011314的专栏
02-26 3549
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace LambdaSpace { public delegate void NoReturnWithPara(int x, int y);
C++11 Lambda表达式深度解析
C++中的Lambda表达式详解，包括基本语法、使用方法等内容，适用于C++程序员学习和参考。 C++中的Lambda表达式是C++11引入的一个重要特性，它允许我们在程序中直接定义匿名函数，使得代码更加简洁、可读性强。Lambda...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值