lambda表达式介绍和底层实现分析

最新推荐文章于 2023-10-15 09:39:39 发布
最新推荐文章于 2023-10-15 09:39:39 发布
阅读量429 收藏 1
点赞数
分类专栏： java 文章标签： java 编程语言 lambda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27215113/article/details/110952090
版权

如果你的需求需要匿名类来实现，例如是一个只有一个方法的接口，那么匿名类的语法可能看起来比较笨拙和不清晰，尽管匿名类比命名类更简洁，但对于只有一个方法的类来说，即使是匿名类也显得有些麻烦。还有在一些情况下，需要将功能作为参数传递给另一个方法，例如当有人单击页面上按钮时应该采取什么操作，javascript可以通过闭包实现。在java语言中，lambda表达式能够将功能视为方法参数，或将代码视为数据，而且lambda表达式可以更紧凑地表达单方法类的实例，在Swing编程和集合（Collections）编程中优势很明显。

一、lambda表达式

lambda表达式，也被称为闭包，它是推动 Java 8 发布的最重要新特性。lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

lambda 表达式的语法格式如下：

(parameters) -> expression或 (parameters) ->{ statements; }

以下是lambda表达式的重要特征:

（1）可选类型声明：不需要声明参数类型，编译器可以统一识别参数值；

（2）可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号；

（3）可选的大括号：如果主体包含了一个语句，就不需要使用大括号；

（4）可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

   使用lambda表达式，可以使用函数式接口，来代替内部类，赋予了Java简单但是强大的函数式编程能力，同时可以认为java支持命令式编程、声明式编程、函数式编程。

 

二、函数式接口

只有一个抽象方法的接口，称为函数式接口。例如下面的接口，

public interface MyFunctionInterface<T> {
    public T getValue(T t);
}

测试类如下

public class MyFunctionInterfaceTest {
    public static void main(String[] args) {
        testMethod("   aaaa  ", s -> s.trim());
        testMethod("   aaaa  ", s -> s.trim().toUpperCase());
    }

    public static void testMethod(String str, 	MyFunctionInterface<String> functionInterface) {
        System.out.println(functionInterface.getValue(str));
    }
}

输出结果如下：

aaaa

AAAA

 

修改一下上面的接口，增加一个方法。

public interface MyFunctionInterface<T> {
    public T getValue(T t);
    public T returnValue(T t);
}

可以看到测试代码就会报错，因为增加一个方法之后，上面就不是函数式接口了。

 

虽然不能在函数式接口中定义多个方法，但可以定义默认方法、静态方法以及java.lang.Object里的public方法。

我们可以在接口上使用@FunctionalInterface注解，如果使用Intellij IDEA可以在编码的时候就看见报错了，这样做可以检查它是否是一个函数式接口。

 

通过反编译，可以看到函数式接口其实就是一个普通的java接口类，如下图。

函数式接口可以作为方法参数传递lambda表达式，但是为了将Lambda表达式作为参数传递，接收Lambda表达式的参数类型必须是与该Lambda表达式兼容的函数式接口的类型。但是我们没必要为每一个lambda表达式创建接口，在jdk的java.util.function包下面已经为我们创建了常用的函数式接口，其中比较核心的是消费型接口（Consumer<T>），供给型接口（Supplier<T>），断言型接口（Predicate<T>），函数型接口（Function<T, R>）四个接口，能够满足大部分应用场景。

 

三、lambda表达式原理分析

继续使用上面的测试代码，可以在IDEA中使用jclasslib Bytecode viewer查看MyFunctionInterface.class源文件。

 

可以看到里面编译器多生成了lambda$main$0和lambda$main$1两个私有静态方法，属性当中多了InnerClasses。我们可以查看一下测试类字节码更详细的反编译结果，如下。

/ class version 52.0 (52)
// access flags 0x21
public class com/para/lambda/MyFunctionInterfaceTest {
  // compiled from: MyFunctionInterfaceTest.java
  // access flags 0x19
  public final static INNERCLASS java/lang/invoke/MethodHandles$Lookup java/lang/invoke/MethodHandles Lookup
  // access flags 0x1

  public <init>()V
   L0
    LINENUMBER 3 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
    RETURN
   L1
    LOCALVARIABLE this Lcom/para/lambda/MyFunctionInterfaceTest; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x9
  public static main([Ljava/lang/String;)V
   L0
    LINENUMBER 5 L0
    LDC "   aaaa  "
    INVOKEDYNAMIC getValue()Lcom/para/lambda/MyFunctionInterface; [
      // handle kind 0x6 : 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;
      // arguments:
      (Ljava/lang/Object;)Ljava/lang/Object;,
      // handle kind 0x6 : INVOKESTATIC
      com/para/lambda/MyFunctionInterfaceTest.lambda$main$0(Ljava/lang/String;)Ljava/lang/String;,
      (Ljava/lang/String;)Ljava/lang/String;
    ]
    INVOKESTATIC com/para/lambda/MyFunctionInterfaceTest.testMethod (Ljava/lang/String;Lcom/para/lambda/MyFunctionInterface;)V
   L1
    LINENUMBER 6 L1
    LDC "   aaaa  "
    INVOKEDYNAMIC getValue()Lcom/para/lambda/MyFunctionInterface; [
      // handle kind 0x6 : 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;
      // arguments:
      (Ljava/lang/Object;)Ljava/lang/Object;,
      // handle kind 0x6 : INVOKESTATIC
      com/para/lambda/MyFunctionInterfaceTest.lambda$main$1(Ljava/lang/String;)Ljava/lang/String;,
      (Ljava/lang/String;)Ljava/lang/String;
    ]
    INVOKESTATIC com/para/lambda/MyFunctionInterfaceTest.testMethod (Ljava/lang/String;Lcom/para/lambda/MyFunctionInterface;)V
   L2
    LINENUMBER 7 L2
    RETURN
   L3
    LOCALVARIABLE args [Ljava/lang/String; L0 L3 0
    MAXSTACK = 2
    MAXLOCALS = 1

  // access flags 0x9
  // signature (Ljava/lang/String;Lcom/para/lambda/MyFunctionInterface<Ljava/lang/String;>;)V
  // declaration: void testMethod(java.lang.String, com.para.lambda.MyFunctionInterface<java.lang.String>)
  public static testMethod(Ljava/lang/String;Lcom/para/lambda/MyFunctionInterface;)V
   L0
    LINENUMBER 9 L0
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    ALOAD 1
    ALOAD 0
    INVOKEINTERFACE com/para/lambda/MyFunctionInterface.getValue (Ljava/lang/Object;)Ljava/lang/Object; (itf)
    CHECKCAST java/lang/String
    INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/String;)V
   L1
    LINENUMBER 10 L1
    RETURN
   L2
    LOCALVARIABLE str Ljava/lang/String; L0 L2 0
    LOCALVARIABLE functionInterface Lcom/para/lambda/MyFunctionInterface; L0 L2 1
    // signature Lcom/para/lambda/MyFunctionInterface<Ljava/lang/String;>;
    // declaration: functionInterface extends com.para.lambda.MyFunctionInterface<java.lang.String>
    MAXSTACK = 3
    MAXLOCALS = 2

  // access flags 0x100A
  private static synthetic lambda$main$1(Ljava/lang/String;)Ljava/lang/String;
   L0
    LINENUMBER 6 L0
    ALOAD 0
    INVOKEVIRTUAL java/lang/String.trim ()Ljava/lang/String;
    INVOKEVIRTUAL java/lang/String.toUpperCase ()Ljava/lang/String;
    ARETURN
   L1
    LOCALVARIABLE s Ljava/lang/String; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x100A
  private static synthetic lambda$main$0(Ljava/lang/String;)Ljava/lang/String;
   L0
    LINENUMBER 5 L0
    ALOAD 0
    INVOKEVIRTUAL java/lang/String.trim ()Ljava/lang/String;
    ARETURN
   L1
    LOCALVARIABLE s Ljava/lang/String; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1
}

可以看到这个私有的静态方法干的就是Lambda表达式里面的内容，那么又是如何调用的生成的私有静态方法呢？通过分析main方法的L0，首先通过INVOKEDYNAMIC 指令调用是MyFunctionInterface的getValue方法的引用，以及后面的指令数组。使用jclasslib Bytecode viewer查看，显示的是调用链，如果想看具体的名称和描述符可以使用javap命令。

INVOKEDYNAMIC 后面的指令数组，首先使用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;   

CallSite是引导类加载器加载的类，该类会动态代理生成一个内部类，该内部类会调用com/para/lambda/MyFunctionInterfaceTest.lambda$main$0方法。

 

所以使用lambda表达式的地方，会在类编译的时候在本类中生成对应的私有静态方法和一个INNERCLASS的访问标识（具体是什么东西没找到资料，注释显示是一个访问标识），该访问标识会调用引导类加载器动态生成内部类，该内部类实现了函数式接口，在实现接口的方法中，会调用编译器生成静态方法，在使用lambda表达式的地方，通过传递内部类实例，来调用函数式接口方法。

总结

    本文从lambda表达式、函数式接口的介绍和对lambda表达式底层原理的分析来认识java中的函数式编程。函数式接口本身就是一个普通的接口，而lambda表达是本质上和匿名内部类是一样的，只不过条件更加苛刻。使用lamda表达式可以以一种更优雅的方式来编程。

ParallelUniverses
关注
专栏目录
Java框架！深入底层原理—带你看透Lambda表达式的本质
目标检测专栏持续更新中，改进YOLO系列通用，适用v5、v7、v8、所有博客均是团队原创博客，所有文章禁止转载，违者必究。
08-05 606
===================================================================== 嗨咯，大家好，今天给带大家深入底层原理看透Lambda表达式的本质，如果本文对你有帮助，记得一键三连一下！！ 知识点 ====================================================================== Lambda的原理 Java 8支持动态语言，看到很酷的Lambda表达式，对一直以静态类型语言自居的Jav
C++ lambda 表达式深剖
qq_61500888的博客
10-16 2372
带你一命通关C++ lambda 表达式 十分钟手撕语法内涵
Lambda表达式介绍和底层实现
Tester_muller的博客
08-25 666
所以使用lambda表达式的地方，会在类编译的时候在本类中生成对应的私有静态方法和一个INNERCLASS的访问标识（具体是什么东西没找到资料，注释显示是一个访问标识），该访问标识会调用引导类加载器动态生成内部类，该内部类实现了函数式接口，在实现接口的方法中，会调用编译器生成静态方法，在使用lambda表达式的地方，通过传递内部类实例，来调用函数式接口方法。函数式接口本身就是一个普通的接口，而lambda表达式本质上和匿名内部类是一样的，只不过条件更加苛刻。...
lambda表达式底层处理机制
weixin_34364071的博客
11-26 325
为了支持函数式编程，Java8引入了Lambda表达式，那么在Java8中到底是如何实现Lambda表达式的呢?Lambda表达式经过编译之后，到底会生成什么东西呢?在没有深入分析前，让我们先想一想，Java8中每一个Lambda表达式必须有一个函数式接口与之对应，函数式接口与普通接口的区别，可以参考前面的内容，那么你或许在想Lambda表达式是不是转化成与之对应的函数式接口的一个实...
字节码之 Lambda 表达式底层原理
最新发布
日拱一卒无有尽，功不唐捐终入海
10-15 407
前两章我们了解了JVM之所以夸平台的一个重要特性，字节码指令、并且通过javap反编译了一些常见的java 语句的字节码指令，了解了之所以这些语句举报那样的特性。今天我们从字节码指令层面聊聊Lambda表达式的底层原理。首先我们写一个简单的lambda表达式，并用javap命令反编译成字节码指令。（动态方法调用）是Java 7引入的一个新的字节码指令，目的是为了支持动态类型语言在Java平台上的执行。这个指令特别适用于执行那些在编译时类型未知的方法调用。在Lambda表达式中，
C++进阶(八) :Lambda 表达式及底层实现原理【详解】
holly的专栏
02-10 2440
c++ lambda
java8 探讨与分析匿名内部类、lambda表达式、方法引用的底层实现的测试用例
03-21
通过分析这些测试用例，开发者可以更深入地理解这些Java 8新特性的实际应用和底层实现。 总之，Java 8的匿名内部类、Lambda表达式和方法引用是面向函数编程的重要工具，它们使得Java更加简洁、高效。通过实践和测试...
java lambda表达式用法总结
08-25
Lambda 表达式的底层实现是基于匿名内部类的。编译器会将 Lambda 表达式编译成一个匿名内部类，并将其实例化以便使用。 例如： BinaryOperator binaryOperator = (int a, int b) -> {return a + b;}; 在上面的...
C++11-lambda表达式
weixin_45599288的博客
02-24 1063
lambda表达式可变模板参数一级目录二级目录三级目录 可变模板参数 C++11中新增加了可变模板参数，它对参数进行了高度泛化，它能表示0到任意个数、任意类型的参数。相比C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。掌握可变模板参数的基本使用即可。 可变模板参数的定义： 一级目录 二级目录 三级目录 ...
Lambda表达式介绍和底层实现分析
ceba20200309的博客
02-17 161
所以使用lambda表达式的地方，会在类编译的时候在本类中生成对应的私有静态方法和一个INNERCLASS的访问标识（具体是什么东西没找到资料，注释显示是一个访问标识），该访问标识会调用引导类加载器动态生成内部类，该内部类实现了函数式接口，在实现接口的方法中，会调用编译器生成静态方法，在使用lambda表达式的地方，通过传递内部类实例，来调用函数式接口方法。函数式接口本身就是一个普通的接口，而lambda表达式本质上和匿名内部类是一样的，只不过条件更加苛刻。
Lambda表达式
Demo_x的博客
12-24 328
一、概念   Lambda表达式，是Java8中最重要的新特性。它是一种匿名函数，有声明的方法，也即没有访问修饰符、返回值声明和名字。允许把函数作为一个方法的参数（函数作为参数传递进方法中），可以使代码变的更加简洁紧凑。 二、语法格式 Lambda表达式有两种语法结构： 方法体为表达式，该表达式的值作为返回值返回。 (parameters) -> expression 方法体为代码块...
Lambda表达式从用到底层原理
weixin_52259848的博客
12-21 1392
Lambda表达式从用到底层原理
java Lambda表达式学习笔记
qq_25452989的博客
09-29 264
Lambda表达式的不同形式 Runnable noArguments = () -&gt; System.out.println("Hello World");➊ ActionListener oneArgument = event -&gt; System.out.println("button clicked");➋ Runnable multiStatement = () -&gt;...
Lambda表达式底层运行原理
养只狗名叫猫
12-08 1132
一、手动利用记事本编写Java测试代码 二、使用命令行进行编译 javac TestDemo.java 编译后会生成两个class文件 查看编译后的class文件 javap -p InterDemo.class E:\test>javac TestDemo.java E:\test>javap -p TestDemo.class Compiled from "...
c++函数对象与lambda表达式实现原理
LIJIWEI0611的博客
11-20 971
函数对象 函数对象:拥有()operator重载函数的对象即函数对象，函数对象类似C语言里面的函数指针，但在C++里为函数对象。 什么是函数对象 例如：我们C语言进行函数调用与C++中两个函数调用。 看起来它们好像一模一样，但是C语言中的sum()，是函数名为一个地址；但C++中的sum()为一个对象，sum调用自己的()重载函数将10与20传给sum调用的()运算符重载函数了，它接受两个实参，再执行a+b。 即：sum.operator()(10,20) 使用函数对象好...
Lambda底层原理最强解析
琪琪的博客
03-20 1834
最近再次重温Lambda函数编程这本书的时候，思考起第一次看这本书只是为了了解如何深入使用Lambda，却没有去思考为什么可以Lambda了，话比较绕口~~哈哈 你可能会好奇Java编译器是如何实现Lambda表达式，而Java虚拟机又是如何对它们进行处理的。如果你认为Lambda表达式就是简单地被转换为匿名类，那就太天真了。 由于Lambda表达式提供了函数式接口中抽象方法的实现，这让人有一种感觉，似乎在编译过程中让Java编译器直接将Lambda表达式转换为匿名类更直观。不过，匿名类有着种种不尽如人
深入解读函数式接口
zy1992As的博客
04-24 705
6.以上分析,仍然是按照面向对象中方法调用的思路展开的,但实质上,我们要注意,Function接口中的andThen方法,返回的是一个Function,里面采用的是lambda表达式,其实是在做函数模型的拼接,把两个函数模型fun1和fun2拼接出一个新的模型,返回新的模型。以及常用的函数式接口。在以后实际的编程过程中，对于集合的操作,可以通过Stream流完成,而Stream流中的很多方法的参数都是函数式接口,通过本文的学习,你已经掌握了函数式接口的使用,相信后面学习Stream流是非常容易的。
spark java.lang.AbstractMethodError:xxx$1.call(Ljava/lang/Object;)Ljava/util/I
u013958151的博客
12-29 299
spark submit 运行程序报错，最后找到原因是版本不兼容 首先spark软件版本要一致，其次是maven的spark版本要和软件版本对应 版本都合上之后问题解决 ...
C++高级——function应用及底层实现
0 error(s)
07-23 2415
function function 这个东西我了解也不是很多，如有错误，请大佬们指正。 function是一个函数包装器模板，最早来自boost库。在c11标准中将其纳入标准库。该函数包装器模板可以包装任何类型的可调用元素，例如普通函数和函数对象。 我老师说，function最大的作用就是保留可调用元素的类型。 function的应用 我们先随便写几个函数： void hello1() { cout << "hello world!" << endl; } void hello2
lambda表达式遍历底层
07-28
lambda表达式是一种匿名函数的表示方式，它可以用于简化代码和执行一些简单的操作。在Python中，lambda表达式通常与内置的函数（如map，filter和reduce）一起使用。 要遍历底层数据结构，你可以使用lambda表达式与...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值