Lambda表达式类似匿名函数，简单地说，它是没有声明的方法，也即没有访问修饰符、返回值声明和方法名。
Lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中）。
Lambda表达式的语法
(parameters) -> expression 或 (parameters) -> { statements; }
登入後複製
参数说明：
可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指明表达式返回了一个数值。
举例说明：
// 1. 不需要参数,返回值为5 () -> 5 // 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)
登入後複製
Lambda表达式作用域
lambda表达式中可以引用任何外部的变量或者常量。但是对这些外部的变量是有要求的：它们必须是Effectively final的。
局部内部类和匿名内部类访问的局部变量必须由final修饰，java8开始，可以不加final修饰符，由系统默认添加。java将这个功能称为：Effectively final功能。
方法引用
指向静态方法的方法引用
Function function1 = Integer::parseInt; // 等价于下面 Function function2 = (String i) -> Integer.parseInt(i);
登入後複製
指向任意类型实例方法的方法引用
Function function3 = String::toLowerCase; // 等价于下面 Function function4 = (String i) -> i.toLowerCase(); BiFunction biFunction = (String s, Integer i) -> s.substring(i); BiFunction biFunction2 = String::substring;
登入後複製
指向现有对象的实例方法的方法引用
String str = "hello"; Supplier supplier = () -> str.length(); Supplier supplier2 = str::length; Function function5 = (Integer i) -> str.substring(i); Function function6 = str::substring;
登入後複製
构造方法引用
package com.morris.java8.lamdba; import java.util.function.BiFunction; import java.util.function.Function; import java.util.function.Supplier; public class MethodReferenceExample { public static void main(String[] args) { // 构造函数引用 Supplier stringSupplier = () -> new String(); Supplier stringSupplier2 = String::new; Function stringFunction = (String s)->new String(s); Function stringFunction2 = String::new; BiFunction stringBiFunction = (Runnable r, String b)-> new Thread(r, b); BiFunction stringBiFunction2 = Thread::new; ThreeFunction threeFunction = (ThreadGroup g, Runnable r, String b)-> new Thread(g, r, b); ThreeFunction threeFunction2 = Thread::new; } interface ThreeFunction { D triple(A a, B b, C c); } }
登入後複製
lambda与匿名内部类
从表面上看到Lambda表达式似乎只是为了简化匿名内部类书写，这看起来仅仅通过语法糖在编译阶段把所有的Lambda表达式替换成匿名内部类就可以了。但实际并非如此。在JVM层面，Lambda表达式和匿名内部类有着明显的差别。
匿名内部类
匿名内部类仍然是一个类，只是不需要程序员显示指定类名，编译器会自动为该类取名。
public class AnonymousClassDemo { public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { System.out.println("this is an Anonymous class demo"); } }); } }
登入後複製
因此上面的代码，编译之后将会产生两个class文件：
AnonymousClassDemo.class AnonymousClassDemo$1.class
登入後複製
进一步分析主类AnonymousClassDemo.class的字节码，可发现其创建了匿名内部类的对象：
$ javap -v -p AnonymousClassDemo.class ... public static void main(java.lang.String[]); descriptor: ([Ljava/lang/String;)V flags: ACC_PUBLIC, ACC_STATIC Code: stack=4, locals=1, args_size=1 0: new #2 // class java/lang/Thread 3: dup 4: new #3 // class AnonymousClassDemo$1 创建匿名内部类 7: dup 8: invokespecial #4 // Method AnonymousClassDemo$1."":()V 11: invokespecial #5 // Method java/lang/Thread."":(Ljava/lang/Runnable;)V 14: pop 15: return LineNumberTable: line 5: 0 line 11: 15 } SourceFile: "AnonymousClassDemo.java" InnerClasses: static #3; //class AnonymousClassDemo$1
登入後複製
lambda表达式
Lambda表达式通过invokedynamic指令实现，不会产生新的类。
public class LambdaDemo { public static void main(String[] args) { new Thread(()-> System.out.println("this is a lambda demo")); } }
登入後複製
上面的代码编译之后只有一个class文件:
通过javap查看LambdaDemo.class的字节码，我们更能看出Lambda表达式内部表示的不同。
$ javap -v -p LambdaDemo.class ... 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; 使用invokedynamic指令调用 9: invokespecial #4 // Method java/lang/Thread."":(Ljava/lang/Runnable;)V 12: pop 13: return LineNumberTable: line 4: 0 line 5: 13 private static void lambda$main$0(); // Lambda表达式被封装成主类的私有方法 descriptor: ()V flags: ACC_PRIVATE, ACC_STATIC, ACC_SYNTHETIC Code: stack=2, locals=0, args_size=0 0: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream; 3: ldc #6 // String this is a lambda demo 5: invokevirtual #7 // Method java/io/PrintStream.println:(Ljava/lang/String;)V 8: return LineNumberTable: line 4: 0 } SourceFile: "LambdaDemo.java" InnerClasses: public static final #51= #50 of #54; //Lookup=class java/lang/invoke/MethodHandles$Lookup of class java/lang/invoke/MethodHandles BootstrapMethods: 0: #22 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: #23 ()V #24 invokestatic LambdaDemo.lambda$main$0:()V #23 ()V
登入後複製
反编译之后我们发现Lambda表达式被封装成了主类的一个私有方法，并通过invokedynamic指令进行调用。
既然Lambda表达式不是内部类的简写，那么Lambda内部的this引用也就跟内部类对象没什么关系了。在Lambda表达式中this的意义跟在表达式外部完全一样。
以上是Java8 Lambda表達式的語法是什麼？的詳細內容。更多資訊請關注PHP中文網其他相關文章！
